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_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3922 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3923 {
3924 USE_OPLINE
3925 zend_function *fbc;
3926 zend_execute_data *call;
3927 fbc = CACHED_PTR(opline->result.num);
3928 if (UNEXPECTED(fbc == NULL)) {
3929 fbc = Z_PTR(EG(function_table)->arData[Z_EXTRA_P(RT_CONSTANT(opline, opline->op2))].val);
3930 CACHE_PTR(opline->result.num, fbc);
3931 }
3932 call = _zend_vm_stack_push_call_frame_ex(
3933 opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
3934 fbc, opline->extended_value, NULL);
3935 call->prev_execute_data = EX(call);
3936 EX(call) = call;
3937 ZEND_VM_NEXT_OPCODE();
3938 }
3939
ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3940 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3941 {
3942 USE_OPLINE
3943 uint32_t arg_num;
3944 zval *param;
3945
3946 ZEND_VM_REPEATABLE_OPCODE
3947
3948 arg_num = opline->op1.num;
3949 param = EX_VAR(opline->result.var);
3950 if (arg_num > EX_NUM_ARGS()) {
3951 zval *default_value = RT_CONSTANT(opline, opline->op2);
3952
3953 if (Z_OPT_TYPE_P(default_value) == IS_CONSTANT_AST) {
3954 zval *cache_val = (zval*)CACHE_ADDR(Z_CACHE_SLOT_P(default_value));
3955
3956 /* we keep in cache only not refcounted values */
3957 if (Z_TYPE_P(cache_val) != IS_UNDEF) {
3958 ZVAL_COPY_VALUE(param, cache_val);
3959 } else {
3960 SAVE_OPLINE();
3961 ZVAL_COPY(param, default_value);
3962 zend_ast_evaluate_ctx ctx = {0};
3963 if (UNEXPECTED(zval_update_constant_with_ctx(param, EX(func)->op_array.scope, &ctx) != SUCCESS)) {
3964 zval_ptr_dtor_nogc(param);
3965 ZVAL_UNDEF(param);
3966 HANDLE_EXCEPTION();
3967 }
3968 if (!Z_REFCOUNTED_P(param) && !ctx.had_side_effects) {
3969 ZVAL_COPY_VALUE(cache_val, param);
3970 }
3971 }
3972 goto recv_init_check_type;
3973 } else {
3974 ZVAL_COPY(param, default_value);
3975 }
3976 } else {
3977 recv_init_check_type:
3978 if ((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0) {
3979 SAVE_OPLINE();
3980 if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), arg_num, param, CACHE_ADDR(opline->extended_value)))) {
3981 HANDLE_EXCEPTION();
3982 }
3983 }
3984 }
3985
3986 ZEND_VM_REPEAT_OPCODE(ZEND_RECV_INIT);
3987 ZEND_VM_NEXT_OPCODE();
3988 }
3989
ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3990 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3991 {
3992 USE_OPLINE
3993 zval *function_name;
3994 zend_execute_data *call;
3995
3996 SAVE_OPLINE();
3997 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
3998
3999 try_function_name:
4000 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4001 call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4002 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4003 call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4004 } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4005 call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4006 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4007 function_name = Z_REFVAL_P(function_name);
4008 goto try_function_name;
4009 } else {
4010 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4011 function_name = ZVAL_UNDEFINED_OP2();
4012 if (UNEXPECTED(EG(exception) != NULL)) {
4013 HANDLE_EXCEPTION();
4014 }
4015 }
4016 zend_throw_error(NULL, "Value of type %s is not callable",
4017 zend_zval_type_name(function_name));
4018 call = NULL;
4019 }
4020
4021 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) {
4022 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
4023 if (UNEXPECTED(EG(exception))) {
4024 if (call) {
4025 if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4026 zend_string_release_ex(call->func->common.function_name, 0);
4027 zend_free_trampoline(call->func);
4028 }
4029 zend_vm_stack_free_call_frame(call);
4030 }
4031 HANDLE_EXCEPTION();
4032 }
4033 } else if (!call) {
4034 HANDLE_EXCEPTION();
4035 }
4036
4037 call->prev_execute_data = EX(call);
4038 EX(call) = call;
4039
4040 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4041 }
4042
ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4043 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4044 {
4045 USE_OPLINE
4046 uint32_t arg_num = opline->op1.num;
4047 zval *param;
4048
4049 if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
4050 ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4051 }
4052
4053 param = EX_VAR(opline->result.var);
4054
4055 if (UNEXPECTED(!(opline->op2.num & (1u << Z_TYPE_P(param))))) {
4056 ZEND_VM_TAIL_CALL(zend_verify_recv_arg_type_helper_SPEC(param ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
4057 }
4058
4059 ZEND_VM_NEXT_OPCODE();
4060 }
4061
ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4062 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4063 {
4064 USE_OPLINE
4065 uint32_t arg_num = opline->op1.num;
4066 uint32_t arg_count = EX_NUM_ARGS();
4067 zval *params;
4068
4069 SAVE_OPLINE();
4070
4071 params = EX_VAR(opline->result.var);
4072
4073 if (arg_num <= arg_count) {
4074 ZEND_ASSERT(EX(func)->common.fn_flags & ZEND_ACC_VARIADIC);
4075 ZEND_ASSERT(EX(func)->common.num_args == arg_num - 1);
4076 zend_arg_info *arg_info = &EX(func)->common.arg_info[arg_num - 1];
4077
4078 array_init_size(params, arg_count - arg_num + 1);
4079 zend_hash_real_init_packed(Z_ARRVAL_P(params));
4080 ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(params)) {
4081 zval *param = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
4082 if (ZEND_TYPE_IS_SET(arg_info->type)) {
4083 ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_FREE_EXTRA_ARGS);
4084 do {
4085 if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param, CACHE_ADDR(opline->extended_value)))) {
4086 ZEND_HASH_FILL_FINISH();
4087 HANDLE_EXCEPTION();
4088 }
4089
4090 if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4091 ZEND_HASH_FILL_ADD(param);
4092 param++;
4093 } while (++arg_num <= arg_count);
4094 } else {
4095 do {
4096 if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4097 ZEND_HASH_FILL_ADD(param);
4098 param++;
4099 } while (++arg_num <= arg_count);
4100 }
4101 } ZEND_HASH_FILL_END();
4102 } else {
4103 ZVAL_EMPTY_ARRAY(params);
4104 }
4105
4106 if (EX_CALL_INFO() & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
4107 zend_string *name;
4108 zval *param;
4109 zend_arg_info *arg_info = &EX(func)->common.arg_info[EX(func)->common.num_args];
4110 if (ZEND_TYPE_IS_SET(arg_info->type)) {
4111 SEPARATE_ARRAY(params);
4112 ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) {
4113 if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param, CACHE_ADDR(opline->extended_value)))) {
4114 HANDLE_EXCEPTION();
4115 }
4116 Z_TRY_ADDREF_P(param);
4117 zend_hash_add_new(Z_ARRVAL_P(params), name, param);
4118 } ZEND_HASH_FOREACH_END();
4119 } else if (zend_hash_num_elements(Z_ARRVAL_P(params)) == 0) {
4120 GC_ADDREF(EX(extra_named_params));
4121 ZVAL_ARR(params, EX(extra_named_params));
4122 } else {
4123 SEPARATE_ARRAY(params);
4124 ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) {
4125 Z_TRY_ADDREF_P(param);
4126 zend_hash_add_new(Z_ARRVAL_P(params), name, param);
4127 } ZEND_HASH_FOREACH_END();
4128 }
4129 }
4130
4131 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4132 }
4133
ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4134 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4135 {
4136 USE_OPLINE
4137 SAVE_OPLINE();
4138 zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline);
4139 ZVAL_NULL(EX_VAR(opline->result.var));
4140 zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
4141 if (EG(exception)) {
4142 FREE_OP(opline->op1_type, opline->op1.var);
4143 HANDLE_EXCEPTION();
4144 }
4145 function(EX_VAR(opline->result.var), arg1);
4146 FREE_OP(opline->op1_type, opline->op1.var);
4147 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4148 }
4149
ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4150 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4151 {
4152 USE_OPLINE
4153 zval *function_name;
4154 zend_execute_data *call;
4155
4156 SAVE_OPLINE();
4157 function_name = EX_VAR(opline->op2.var);
4158
4159 try_function_name:
4160 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4161 call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4162 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4163 call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4164 } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4165 call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4166 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4167 function_name = Z_REFVAL_P(function_name);
4168 goto try_function_name;
4169 } else {
4170 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4171 function_name = ZVAL_UNDEFINED_OP2();
4172 if (UNEXPECTED(EG(exception) != NULL)) {
4173 HANDLE_EXCEPTION();
4174 }
4175 }
4176 zend_throw_error(NULL, "Value of type %s is not callable",
4177 zend_zval_type_name(function_name));
4178 call = NULL;
4179 }
4180
4181 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
4182
4183 if (UNEXPECTED(EG(exception))) {
4184 if (call) {
4185 if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4186 zend_string_release_ex(call->func->common.function_name, 0);
4187 zend_free_trampoline(call->func);
4188 }
4189 zend_vm_stack_free_call_frame(call);
4190 }
4191 HANDLE_EXCEPTION();
4192 }
4193 } else if (!call) {
4194 HANDLE_EXCEPTION();
4195 }
4196
4197 call->prev_execute_data = EX(call);
4198 EX(call) = call;
4199
4200 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4201 }
4202
ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4203 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4204 {
4205 USE_OPLINE
4206 zval *op1;
4207
4208 op1 = RT_CONSTANT(opline, opline->op1);
4209 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
4210 ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
4211 ZEND_VM_NEXT_OPCODE();
4212 }
4213
4214 ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(op1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
4215 }
4216
ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4217 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4218 {
4219 USE_OPLINE
4220 zval *val;
4221
4222 val = RT_CONSTANT(opline, opline->op1);
4223 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4224 ZVAL_FALSE(EX_VAR(opline->result.var));
4225 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4226 /* The result and op1 can be the same cv zval */
4227 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
4228 ZVAL_TRUE(EX_VAR(opline->result.var));
4229 if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
4230 SAVE_OPLINE();
4231 ZVAL_UNDEFINED_OP1();
4232 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4233 }
4234 } else {
4235 SAVE_OPLINE();
4236 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
4237
4238 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4239 }
4240 ZEND_VM_NEXT_OPCODE();
4241 }
4242
ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4243 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4244 {
4245 USE_OPLINE
4246 zval *z;
4247
4248 SAVE_OPLINE();
4249 z = RT_CONSTANT(opline, opline->op1);
4250
4251 if (Z_TYPE_P(z) == IS_STRING) {
4252 zend_string *str = Z_STR_P(z);
4253
4254 if (ZSTR_LEN(str) != 0) {
4255 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
4256 }
4257 } else {
4258 zend_string *str = zval_get_string_func(z);
4259
4260 if (ZSTR_LEN(str) != 0) {
4261 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
4262 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
4263 ZVAL_UNDEFINED_OP1();
4264 }
4265 zend_string_release_ex(str, 0);
4266 }
4267
4268 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4269 }
4270
ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4271 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4272 {
4273 USE_OPLINE
4274 zval *val;
4275 uint8_t op1_type;
4276
4277 val = RT_CONSTANT(opline, opline->op1);
4278
4279 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4280 ZEND_VM_NEXT_OPCODE();
4281 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4282 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4283 SAVE_OPLINE();
4284 ZVAL_UNDEFINED_OP1();
4285 if (UNEXPECTED(EG(exception))) {
4286 HANDLE_EXCEPTION();
4287 }
4288 }
4289 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4290 }
4291
4292 SAVE_OPLINE();
4293 op1_type = IS_CONST;
4294 if (i_zend_is_true(val)) {
4295 opline++;
4296 } else {
4297 opline = OP_JMP_ADDR(opline, opline->op2);
4298 }
4299 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
4300 zval_ptr_dtor_nogc(val);
4301 }
4302 ZEND_VM_JMP(opline);
4303 }
4304
ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4305 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4306 {
4307 USE_OPLINE
4308 zval *val;
4309 uint8_t op1_type;
4310
4311 val = RT_CONSTANT(opline, opline->op1);
4312
4313 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4314 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4315 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4316 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4317 SAVE_OPLINE();
4318 ZVAL_UNDEFINED_OP1();
4319 if (UNEXPECTED(EG(exception))) {
4320 HANDLE_EXCEPTION();
4321 }
4322 }
4323 ZEND_VM_NEXT_OPCODE();
4324 }
4325
4326 SAVE_OPLINE();
4327 op1_type = IS_CONST;
4328 if (i_zend_is_true(val)) {
4329 opline = OP_JMP_ADDR(opline, opline->op2);
4330 } else {
4331 opline++;
4332 }
4333 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
4334 zval_ptr_dtor_nogc(val);
4335 }
4336 ZEND_VM_JMP(opline);
4337 }
4338
ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4339 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4340 {
4341 USE_OPLINE
4342 zval *val;
4343 bool ret;
4344
4345 val = RT_CONSTANT(opline, opline->op1);
4346
4347 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4348 ZVAL_TRUE(EX_VAR(opline->result.var));
4349 ZEND_VM_NEXT_OPCODE();
4350 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4351 ZVAL_FALSE(EX_VAR(opline->result.var));
4352 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4353 SAVE_OPLINE();
4354 ZVAL_UNDEFINED_OP1();
4355 if (UNEXPECTED(EG(exception))) {
4356 HANDLE_EXCEPTION();
4357 }
4358 }
4359 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4360 }
4361
4362 SAVE_OPLINE();
4363 ret = i_zend_is_true(val);
4364
4365 if (ret) {
4366 ZVAL_TRUE(EX_VAR(opline->result.var));
4367 opline++;
4368 } else {
4369 ZVAL_FALSE(EX_VAR(opline->result.var));
4370 opline = OP_JMP_ADDR(opline, opline->op2);
4371 }
4372 ZEND_VM_JMP(opline);
4373 }
4374
ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4375 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4376 {
4377 USE_OPLINE
4378 zval *val;
4379 bool ret;
4380
4381 val = RT_CONSTANT(opline, opline->op1);
4382
4383 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4384 ZVAL_TRUE(EX_VAR(opline->result.var));
4385 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4386 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4387 ZVAL_FALSE(EX_VAR(opline->result.var));
4388 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4389 SAVE_OPLINE();
4390 ZVAL_UNDEFINED_OP1();
4391 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4392 } else {
4393 ZEND_VM_NEXT_OPCODE();
4394 }
4395 }
4396
4397 SAVE_OPLINE();
4398 ret = i_zend_is_true(val);
4399
4400 if (ret) {
4401 ZVAL_TRUE(EX_VAR(opline->result.var));
4402 opline = OP_JMP_ADDR(opline, opline->op2);
4403 } else {
4404 ZVAL_FALSE(EX_VAR(opline->result.var));
4405 opline++;
4406 }
4407 ZEND_VM_JMP(opline);
4408 }
4409
ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4410 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4411 {
4412 USE_OPLINE
4413 zval *retval_ptr;
4414 zval *return_value;
4415
4416 retval_ptr = RT_CONSTANT(opline, opline->op1);
4417 return_value = EX(return_value);
4418
4419 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
4420 SAVE_OPLINE();
4421 retval_ptr = ZVAL_UNDEFINED_OP1();
4422 if (return_value) {
4423 ZVAL_NULL(return_value);
4424 }
4425 } else if (!return_value) {
4426 if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
4427 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
4428 SAVE_OPLINE();
4429 rc_dtor_func(Z_COUNTED_P(retval_ptr));
4430 }
4431 }
4432 } else {
4433 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
4434 ZVAL_COPY_VALUE(return_value, retval_ptr);
4435 if (IS_CONST == IS_CONST) {
4436 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
4437 Z_ADDREF_P(return_value);
4438 }
4439 }
4440 } else if (IS_CONST == IS_CV) {
4441 do {
4442 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4443 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
4444 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
4445 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4446 ZVAL_COPY_VALUE(return_value, retval_ptr);
4447 if (GC_MAY_LEAK(ref)) {
4448 SAVE_OPLINE();
4449 gc_possible_root(ref);
4450 }
4451 ZVAL_NULL(retval_ptr);
4452 break;
4453 } else {
4454 Z_ADDREF_P(retval_ptr);
4455 }
4456 } else {
4457 retval_ptr = Z_REFVAL_P(retval_ptr);
4458 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4459 Z_ADDREF_P(retval_ptr);
4460 }
4461 }
4462 }
4463 ZVAL_COPY_VALUE(return_value, retval_ptr);
4464 } while (0);
4465 } else /* if (IS_CONST == IS_VAR) */ {
4466 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4467 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4468
4469 retval_ptr = Z_REFVAL_P(retval_ptr);
4470 ZVAL_COPY_VALUE(return_value, retval_ptr);
4471 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4472 efree_size(ref, sizeof(zend_reference));
4473 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4474 Z_ADDREF_P(retval_ptr);
4475 }
4476 } else {
4477 ZVAL_COPY_VALUE(return_value, retval_ptr);
4478 }
4479 }
4480 }
4481
4482
4483
4484 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4485 }
4486
ZEND_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4487 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4488 {
4489 USE_OPLINE
4490 zval *retval_ptr;
4491 zval *return_value;
4492 zval observer_retval;
4493
4494 retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
4495 return_value = EX(return_value);
4496 if (!return_value) { return_value = &observer_retval; };
4497 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
4498 SAVE_OPLINE();
4499 retval_ptr = ZVAL_UNDEFINED_OP1();
4500 if (return_value) {
4501 ZVAL_NULL(return_value);
4502 }
4503 } else if (!return_value) {
4504 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
4505 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
4506 SAVE_OPLINE();
4507 rc_dtor_func(Z_COUNTED_P(retval_ptr));
4508 }
4509 }
4510 } else {
4511 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
4512 ZVAL_COPY_VALUE(return_value, retval_ptr);
4513 if (opline->op1_type == IS_CONST) {
4514 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
4515 Z_ADDREF_P(return_value);
4516 }
4517 }
4518 } else if (opline->op1_type == IS_CV) {
4519 do {
4520 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4521 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
4522 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
4523 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4524 ZVAL_COPY_VALUE(return_value, retval_ptr);
4525 if (GC_MAY_LEAK(ref)) {
4526 SAVE_OPLINE();
4527 gc_possible_root(ref);
4528 }
4529 ZVAL_NULL(retval_ptr);
4530 break;
4531 } else {
4532 Z_ADDREF_P(retval_ptr);
4533 }
4534 } else {
4535 retval_ptr = Z_REFVAL_P(retval_ptr);
4536 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4537 Z_ADDREF_P(retval_ptr);
4538 }
4539 }
4540 }
4541 ZVAL_COPY_VALUE(return_value, retval_ptr);
4542 } while (0);
4543 } else /* if (opline->op1_type == IS_VAR) */ {
4544 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4545 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4546
4547 retval_ptr = Z_REFVAL_P(retval_ptr);
4548 ZVAL_COPY_VALUE(return_value, retval_ptr);
4549 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4550 efree_size(ref, sizeof(zend_reference));
4551 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4552 Z_ADDREF_P(retval_ptr);
4553 }
4554 } else {
4555 ZVAL_COPY_VALUE(return_value, retval_ptr);
4556 }
4557 }
4558 }
4559 SAVE_OPLINE();
4560 zend_observer_fcall_end(execute_data, return_value);
4561 if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
4562 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4563 }
4564
ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4565 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4566 {
4567 USE_OPLINE
4568 zval *retval_ptr;
4569 zval *return_value;
4570
4571 SAVE_OPLINE();
4572
4573 return_value = EX(return_value);
4574
4575 do {
4576 if ((IS_CONST & (IS_CONST|IS_TMP_VAR)) ||
4577 (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4578 /* Not supposed to happen, but we'll allow it */
4579 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4580
4581 retval_ptr = RT_CONSTANT(opline, opline->op1);
4582 if (!return_value) {
4583
4584 } else {
4585 if (IS_CONST == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4586 ZVAL_COPY_VALUE(return_value, retval_ptr);
4587 break;
4588 }
4589
4590 ZVAL_NEW_REF(return_value, retval_ptr);
4591 if (IS_CONST == IS_CONST) {
4592 Z_TRY_ADDREF_P(retval_ptr);
4593 }
4594 }
4595 break;
4596 }
4597
4598 retval_ptr = zend_get_bad_ptr();
4599
4600 if (IS_CONST == IS_VAR) {
4601 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
4602 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
4603 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4604 if (return_value) {
4605 ZVAL_NEW_REF(return_value, retval_ptr);
4606 } else {
4607
4608 }
4609 break;
4610 }
4611 }
4612
4613 if (return_value) {
4614 if (Z_ISREF_P(retval_ptr)) {
4615 Z_ADDREF_P(retval_ptr);
4616 } else {
4617 ZVAL_MAKE_REF_EX(retval_ptr, 2);
4618 }
4619 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
4620 }
4621
4622 } while (0);
4623
4624
4625 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4626 }
4627
ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4628 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4629 {
4630 USE_OPLINE
4631 zval *retval_ptr;
4632 zval *return_value;
4633 zval observer_retval;
4634
4635 SAVE_OPLINE();
4636
4637 return_value = EX(return_value);
4638 if (!return_value) { return_value = &observer_retval; };
4639 do {
4640 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR)) ||
4641 (opline->op1_type == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4642 /* Not supposed to happen, but we'll allow it */
4643 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4644
4645 retval_ptr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
4646 if (!return_value) {
4647 FREE_OP(opline->op1_type, opline->op1.var);
4648 } else {
4649 if (opline->op1_type == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4650 ZVAL_COPY_VALUE(return_value, retval_ptr);
4651 break;
4652 }
4653
4654 ZVAL_NEW_REF(return_value, retval_ptr);
4655 if (opline->op1_type == IS_CONST) {
4656 Z_TRY_ADDREF_P(retval_ptr);
4657 }
4658 }
4659 break;
4660 }
4661
4662 retval_ptr = get_zval_ptr_ptr(opline->op1_type, opline->op1, BP_VAR_W);
4663
4664 if (opline->op1_type == IS_VAR) {
4665 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
4666 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
4667 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4668 if (return_value) {
4669 ZVAL_NEW_REF(return_value, retval_ptr);
4670 } else {
4671 FREE_OP(opline->op1_type, opline->op1.var);
4672 }
4673 break;
4674 }
4675 }
4676
4677 if (return_value) {
4678 if (Z_ISREF_P(retval_ptr)) {
4679 Z_ADDREF_P(retval_ptr);
4680 } else {
4681 ZVAL_MAKE_REF_EX(retval_ptr, 2);
4682 }
4683 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
4684 }
4685
4686 FREE_OP(opline->op1_type, opline->op1.var);
4687 } while (0);
4688
4689 zend_observer_fcall_end(execute_data, return_value);
4690 if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
4691 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4692 }
4693
ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4694 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4695 {
4696 USE_OPLINE
4697 zval *retval;
4698
4699 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
4700
4701 SAVE_OPLINE();
4702 retval = RT_CONSTANT(opline, opline->op1);
4703
4704 /* Copy return value into generator->retval */
4705 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
4706 ZVAL_COPY_VALUE(&generator->retval, retval);
4707 if (IS_CONST == IS_CONST) {
4708 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
4709 Z_ADDREF(generator->retval);
4710 }
4711 }
4712 } else if (IS_CONST == IS_CV) {
4713 ZVAL_COPY_DEREF(&generator->retval, retval);
4714 } else /* if (IS_CONST == IS_VAR) */ {
4715 if (UNEXPECTED(Z_ISREF_P(retval))) {
4716 zend_refcounted *ref = Z_COUNTED_P(retval);
4717
4718 retval = Z_REFVAL_P(retval);
4719 ZVAL_COPY_VALUE(&generator->retval, retval);
4720 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4721 efree_size(ref, sizeof(zend_reference));
4722 } else if (Z_OPT_REFCOUNTED_P(retval)) {
4723 Z_ADDREF_P(retval);
4724 }
4725 } else {
4726 ZVAL_COPY_VALUE(&generator->retval, retval);
4727 }
4728 }
4729
4730 EG(current_execute_data) = EX(prev_execute_data);
4731
4732 /* Close the generator to free up resources */
4733 zend_generator_close(generator, 1);
4734
4735 /* Pass execution back to handling code */
4736 ZEND_VM_RETURN();
4737 }
4738
ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4739 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4740 {
4741 USE_OPLINE
4742 zval *retval;
4743
4744 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
4745
4746 SAVE_OPLINE();
4747 retval = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
4748
4749 /* Copy return value into generator->retval */
4750 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
4751 ZVAL_COPY_VALUE(&generator->retval, retval);
4752 if (opline->op1_type == IS_CONST) {
4753 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
4754 Z_ADDREF(generator->retval);
4755 }
4756 }
4757 } else if (opline->op1_type == IS_CV) {
4758 ZVAL_COPY_DEREF(&generator->retval, retval);
4759 } else /* if (opline->op1_type == IS_VAR) */ {
4760 if (UNEXPECTED(Z_ISREF_P(retval))) {
4761 zend_refcounted *ref = Z_COUNTED_P(retval);
4762
4763 retval = Z_REFVAL_P(retval);
4764 ZVAL_COPY_VALUE(&generator->retval, retval);
4765 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4766 efree_size(ref, sizeof(zend_reference));
4767 } else if (Z_OPT_REFCOUNTED_P(retval)) {
4768 Z_ADDREF_P(retval);
4769 }
4770 } else {
4771 ZVAL_COPY_VALUE(&generator->retval, retval);
4772 }
4773 }
4774
4775 zend_observer_fcall_end(generator->execute_data, &generator->retval);
4776
4777 EG(current_execute_data) = EX(prev_execute_data);
4778
4779 /* Close the generator to free up resources */
4780 zend_generator_close(generator, 1);
4781
4782 /* Pass execution back to handling code */
4783 ZEND_VM_RETURN();
4784 }
4785
ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4786 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4787 {
4788 USE_OPLINE
4789 zval *value;
4790
4791 SAVE_OPLINE();
4792 value = RT_CONSTANT(opline, opline->op1);
4793
4794 do {
4795 if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
4796 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
4797 value = Z_REFVAL_P(value);
4798 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
4799 break;
4800 }
4801 }
4802 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
4803 ZVAL_UNDEFINED_OP1();
4804 if (UNEXPECTED(EG(exception) != NULL)) {
4805 HANDLE_EXCEPTION();
4806 }
4807 }
4808 zend_throw_error(NULL, "Can only throw objects");
4809
4810 HANDLE_EXCEPTION();
4811 }
4812 } while (0);
4813
4814 zend_exception_save();
4815 Z_TRY_ADDREF_P(value);
4816 zend_throw_exception_object(value);
4817 zend_exception_restore();
4818
4819 HANDLE_EXCEPTION();
4820 }
4821
ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4822 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4823 {
4824 USE_OPLINE
4825 zend_class_entry *ce, *catch_ce;
4826 zend_object *exception;
4827
4828 SAVE_OPLINE();
4829 /* Check whether an exception has been thrown, if not, jump over code */
4830 zend_exception_restore();
4831 if (EG(exception) == NULL) {
4832 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4833 }
4834 catch_ce = CACHED_PTR(opline->extended_value & ~ZEND_LAST_CATCH);
4835 if (UNEXPECTED(catch_ce == NULL)) {
4836 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);
4837
4838 CACHE_PTR(opline->extended_value & ~ZEND_LAST_CATCH, catch_ce);
4839 }
4840 ce = EG(exception)->ce;
4841
4842 #ifdef HAVE_DTRACE
4843 if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
4844 DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
4845 }
4846 #endif /* HAVE_DTRACE */
4847
4848 if (ce != catch_ce) {
4849 if (!catch_ce || !instanceof_function(ce, catch_ce)) {
4850 if (opline->extended_value & ZEND_LAST_CATCH) {
4851 zend_rethrow_exception(execute_data);
4852 HANDLE_EXCEPTION();
4853 }
4854 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4855 }
4856 }
4857
4858 exception = EG(exception);
4859 EG(exception) = NULL;
4860 if (RETURN_VALUE_USED(opline)) {
4861 /* Always perform a strict assignment. There is a reasonable expectation that if you
4862 * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
4863 * we should not permit coercion to string here. */
4864 zval tmp;
4865 ZVAL_OBJ(&tmp, exception);
4866 zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
4867 } else {
4868 OBJ_RELEASE(exception);
4869 }
4870 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4871 }
4872
ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4873 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4874 {
4875 USE_OPLINE
4876 zval *arg, *param;
4877
4878 SAVE_OPLINE();
4879
4880 arg = RT_CONSTANT(opline, opline->op1);
4881 param = ZEND_CALL_VAR(EX(call), opline->result.var);
4882 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
4883 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
4884 Z_TRY_ADDREF_P(arg);
4885 ZVAL_NEW_REF(param, arg);
4886 } else {
4887 ZVAL_COPY(param, arg);
4888 }
4889
4890 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4891 }
4892
ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4893 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4894 {
4895 USE_OPLINE
4896 zval *val;
4897
4898 val = RT_CONSTANT(opline, opline->op1);
4899 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4900 ZVAL_TRUE(EX_VAR(opline->result.var));
4901 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4902 /* The result and op1 can be the same cv zval */
4903 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
4904 ZVAL_FALSE(EX_VAR(opline->result.var));
4905 if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
4906 SAVE_OPLINE();
4907 ZVAL_UNDEFINED_OP1();
4908 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4909 }
4910 } else {
4911 SAVE_OPLINE();
4912 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
4913
4914 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4915 }
4916 ZEND_VM_NEXT_OPCODE();
4917 }
4918
ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4919 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4920 {
4921 USE_OPLINE
4922 zval *obj;
4923 zend_object *zobj;
4924 zend_class_entry *ce, *scope;
4925 zend_function *clone;
4926 zend_object_clone_obj_t clone_call;
4927
4928 SAVE_OPLINE();
4929 obj = RT_CONSTANT(opline, opline->op1);
4930
4931 do {
4932 if (IS_CONST == IS_CONST ||
4933 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
4934 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
4935 obj = Z_REFVAL_P(obj);
4936 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
4937 break;
4938 }
4939 }
4940 ZVAL_UNDEF(EX_VAR(opline->result.var));
4941 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
4942 ZVAL_UNDEFINED_OP1();
4943 if (UNEXPECTED(EG(exception) != NULL)) {
4944 HANDLE_EXCEPTION();
4945 }
4946 }
4947 zend_throw_error(NULL, "__clone method called on non-object");
4948
4949 HANDLE_EXCEPTION();
4950 }
4951 } while (0);
4952
4953 zobj = Z_OBJ_P(obj);
4954 ce = zobj->ce;
4955 clone = ce->clone;
4956 clone_call = zobj->handlers->clone_obj;
4957 if (UNEXPECTED(clone_call == NULL)) {
4958 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
4959
4960 ZVAL_UNDEF(EX_VAR(opline->result.var));
4961 HANDLE_EXCEPTION();
4962 }
4963
4964 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
4965 scope = EX(func)->op_array.scope;
4966 if (clone->common.scope != scope) {
4967 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
4968 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
4969 zend_wrong_clone_call(clone, scope);
4970
4971 ZVAL_UNDEF(EX_VAR(opline->result.var));
4972 HANDLE_EXCEPTION();
4973 }
4974 }
4975 }
4976
4977 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
4978
4979 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4980 }
4981
ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4982 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4983 {
4984 USE_OPLINE
4985 zval *expr;
4986 zval *result = EX_VAR(opline->result.var);
4987 HashTable *ht;
4988
4989 SAVE_OPLINE();
4990 expr = RT_CONSTANT(opline, opline->op1);
4991
4992 switch (opline->extended_value) {
4993 case IS_LONG:
4994 ZVAL_LONG(result, zval_get_long(expr));
4995 break;
4996 case IS_DOUBLE:
4997 ZVAL_DOUBLE(result, zval_get_double(expr));
4998 break;
4999 case IS_STRING:
5000 ZVAL_STR(result, zval_get_string(expr));
5001 break;
5002 default:
5003 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
5004 if (IS_CONST & (IS_VAR|IS_CV)) {
5005 ZVAL_DEREF(expr);
5006 }
5007 /* If value is already of correct type, return it directly */
5008 if (Z_TYPE_P(expr) == opline->extended_value) {
5009 ZVAL_COPY_VALUE(result, expr);
5010 if (IS_CONST == IS_CONST) {
5011 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5012 } else if (IS_CONST != IS_TMP_VAR) {
5013 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5014 }
5015
5016 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5017 }
5018
5019 if (opline->extended_value == IS_ARRAY) {
5020 if (IS_CONST == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
5021 if (Z_TYPE_P(expr) != IS_NULL) {
5022 ZVAL_ARR(result, zend_new_array(1));
5023 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
5024 if (IS_CONST == IS_CONST) {
5025 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
5026 } else {
5027 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
5028 }
5029 } else {
5030 ZVAL_EMPTY_ARRAY(result);
5031 }
5032 } else if (Z_OBJ_P(expr)->properties == NULL
5033 && Z_OBJ_HT_P(expr)->get_properties_for == NULL
5034 && Z_OBJ_HT_P(expr)->get_properties == zend_std_get_properties) {
5035 /* Optimized version without rebuilding properties HashTable */
5036 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
5037 } else {
5038 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
5039 if (obj_ht) {
5040 /* fast copy */
5041 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
5042 (Z_OBJCE_P(expr)->default_properties_count ||
5043 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
5044 GC_IS_RECURSIVE(obj_ht))));
5045 zend_release_properties(obj_ht);
5046 } else {
5047 ZVAL_EMPTY_ARRAY(result);
5048 }
5049 }
5050 } else {
5051 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
5052 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
5053 if (Z_TYPE_P(expr) == IS_ARRAY) {
5054 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
5055 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
5056 /* TODO: try not to duplicate immutable arrays as well ??? */
5057 ht = zend_array_dup(ht);
5058 }
5059 Z_OBJ_P(result)->properties = ht;
5060 } else if (Z_TYPE_P(expr) != IS_NULL) {
5061 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
5062 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
5063 if (IS_CONST == IS_CONST) {
5064 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
5065 } else {
5066 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
5067 }
5068 }
5069 }
5070 }
5071
5072 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5073 }
5074
ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5075 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5076 {
5077 USE_OPLINE
5078 zend_op_array *new_op_array;
5079 zval *inc_filename;
5080
5081 SAVE_OPLINE();
5082 inc_filename = RT_CONSTANT(opline, opline->op1);
5083 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
5084 if (UNEXPECTED(EG(exception) != NULL)) {
5085
5086 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
5087 destroy_op_array(new_op_array);
5088 efree_size(new_op_array, sizeof(zend_op_array));
5089 }
5090 UNDEF_RESULT();
5091 HANDLE_EXCEPTION();
5092 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
5093 if (RETURN_VALUE_USED(opline)) {
5094 ZVAL_TRUE(EX_VAR(opline->result.var));
5095 }
5096 } else if (UNEXPECTED(new_op_array == NULL)) {
5097 if (RETURN_VALUE_USED(opline)) {
5098 ZVAL_FALSE(EX_VAR(opline->result.var));
5099 }
5100 } else if (new_op_array->last == 1
5101 && new_op_array->opcodes[0].opcode == ZEND_RETURN
5102 && new_op_array->opcodes[0].op1_type == IS_CONST
5103 && EXPECTED(zend_execute_ex == execute_ex)) {
5104 if (RETURN_VALUE_USED(opline)) {
5105 const zend_op *op = new_op_array->opcodes;
5106
5107 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
5108 }
5109 zend_destroy_static_vars(new_op_array);
5110 destroy_op_array(new_op_array);
5111 efree_size(new_op_array, sizeof(zend_op_array));
5112 } else {
5113 zval *return_value = NULL;
5114 zend_execute_data *call;
5115 if (RETURN_VALUE_USED(opline)) {
5116 return_value = EX_VAR(opline->result.var);
5117 }
5118
5119 new_op_array->scope = EX(func)->op_array.scope;
5120
5121 call = zend_vm_stack_push_call_frame(
5122 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
5123 (zend_function*)new_op_array, 0,
5124 Z_PTR(EX(This)));
5125
5126 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
5127 call->symbol_table = EX(symbol_table);
5128 } else {
5129 call->symbol_table = zend_rebuild_symbol_table();
5130 }
5131
5132 call->prev_execute_data = execute_data;
5133 i_init_code_execute_data(call, new_op_array, return_value);
5134
5135 if (EXPECTED(zend_execute_ex == execute_ex)) {
5136
5137 ZEND_VM_ENTER();
5138 } else {
5139 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5140 zend_execute_ex(call);
5141 zend_vm_stack_free_call_frame(call);
5142 }
5143
5144 zend_destroy_static_vars(new_op_array);
5145 destroy_op_array(new_op_array);
5146 efree_size(new_op_array, sizeof(zend_op_array));
5147 if (UNEXPECTED(EG(exception) != NULL)) {
5148 zend_rethrow_exception(execute_data);
5149
5150 UNDEF_RESULT();
5151 HANDLE_EXCEPTION();
5152 }
5153 }
5154
5155 ZEND_VM_NEXT_OPCODE();
5156 }
5157
ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5158 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5159 {
5160 USE_OPLINE
5161 zend_op_array *new_op_array;
5162 zval *inc_filename;
5163
5164 SAVE_OPLINE();
5165 inc_filename = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
5166 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
5167 if (UNEXPECTED(EG(exception) != NULL)) {
5168 FREE_OP(opline->op1_type, opline->op1.var);
5169 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
5170 destroy_op_array(new_op_array);
5171 efree_size(new_op_array, sizeof(zend_op_array));
5172 }
5173 UNDEF_RESULT();
5174 HANDLE_EXCEPTION();
5175 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
5176 if (RETURN_VALUE_USED(opline)) {
5177 ZVAL_TRUE(EX_VAR(opline->result.var));
5178 }
5179 } else if (UNEXPECTED(new_op_array == NULL)) {
5180 if (RETURN_VALUE_USED(opline)) {
5181 ZVAL_FALSE(EX_VAR(opline->result.var));
5182 }
5183 } else if (new_op_array->last == 1
5184 && new_op_array->opcodes[0].opcode == ZEND_RETURN
5185 && new_op_array->opcodes[0].op1_type == IS_CONST
5186 && EXPECTED(zend_execute_ex == execute_ex)) {
5187 if (RETURN_VALUE_USED(opline)) {
5188 const zend_op *op = new_op_array->opcodes;
5189
5190 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
5191 }
5192 zend_destroy_static_vars(new_op_array);
5193 destroy_op_array(new_op_array);
5194 efree_size(new_op_array, sizeof(zend_op_array));
5195 } else {
5196 zval *return_value = NULL;
5197 zend_execute_data *call;
5198 if (RETURN_VALUE_USED(opline)) {
5199 return_value = EX_VAR(opline->result.var);
5200 }
5201
5202 new_op_array->scope = EX(func)->op_array.scope;
5203
5204 call = zend_vm_stack_push_call_frame(
5205 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
5206 (zend_function*)new_op_array, 0,
5207 Z_PTR(EX(This)));
5208
5209 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
5210 call->symbol_table = EX(symbol_table);
5211 } else {
5212 call->symbol_table = zend_rebuild_symbol_table();
5213 }
5214
5215 call->prev_execute_data = execute_data;
5216 i_init_code_execute_data(call, new_op_array, return_value);
5217 zend_observer_fcall_begin(call);
5218 if (EXPECTED(zend_execute_ex == execute_ex)) {
5219 FREE_OP(opline->op1_type, opline->op1.var);
5220 ZEND_VM_ENTER();
5221 } else {
5222 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5223 zend_execute_ex(call);
5224 zend_vm_stack_free_call_frame(call);
5225 }
5226
5227 zend_destroy_static_vars(new_op_array);
5228 destroy_op_array(new_op_array);
5229 efree_size(new_op_array, sizeof(zend_op_array));
5230 if (UNEXPECTED(EG(exception) != NULL)) {
5231 zend_rethrow_exception(execute_data);
5232 FREE_OP(opline->op1_type, opline->op1.var);
5233 UNDEF_RESULT();
5234 HANDLE_EXCEPTION();
5235 }
5236 }
5237 FREE_OP(opline->op1_type, opline->op1.var);
5238 ZEND_VM_NEXT_OPCODE();
5239 }
5240
ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5241 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5242 {
5243 USE_OPLINE
5244 zval *array_ptr, *result;
5245
5246 SAVE_OPLINE();
5247
5248 array_ptr = RT_CONSTANT(opline, opline->op1);
5249 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5250 result = EX_VAR(opline->result.var);
5251 ZVAL_COPY_VALUE(result, array_ptr);
5252 if (IS_CONST != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
5253 Z_ADDREF_P(array_ptr);
5254 }
5255 Z_FE_POS_P(result) = 0;
5256
5257 ZEND_VM_NEXT_OPCODE();
5258 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5259 zend_object *zobj = Z_OBJ_P(array_ptr);
5260 if (!zobj->ce->get_iterator) {
5261 HashTable *properties = zobj->properties;
5262 if (properties) {
5263 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
5264 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
5265 GC_DELREF(properties);
5266 }
5267 properties = zobj->properties = zend_array_dup(properties);
5268 }
5269 } else {
5270 properties = zobj->handlers->get_properties(zobj);
5271 }
5272
5273 result = EX_VAR(opline->result.var);
5274 ZVAL_COPY_VALUE(result, array_ptr);
5275 if (IS_CONST != IS_TMP_VAR) {
5276 Z_ADDREF_P(array_ptr);
5277 }
5278
5279 if (zend_hash_num_elements(properties) == 0) {
5280 Z_FE_ITER_P(result) = (uint32_t) -1;
5281
5282 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5283 }
5284
5285 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
5286
5287 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5288 } else {
5289 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
5290
5291 if (UNEXPECTED(EG(exception))) {
5292 HANDLE_EXCEPTION();
5293 } else if (is_empty) {
5294 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5295 } else {
5296 ZEND_VM_NEXT_OPCODE();
5297 }
5298 }
5299 } else {
5300 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
5301 ZVAL_UNDEF(EX_VAR(opline->result.var));
5302 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5303
5304 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5305 }
5306 }
5307
ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5308 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5309 {
5310 USE_OPLINE
5311 zval *array_ptr, *array_ref;
5312
5313 SAVE_OPLINE();
5314
5315 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5316 array_ref = array_ptr = zend_get_bad_ptr();
5317 if (Z_ISREF_P(array_ref)) {
5318 array_ptr = Z_REFVAL_P(array_ref);
5319 }
5320 } else {
5321 array_ref = array_ptr = RT_CONSTANT(opline, opline->op1);
5322 }
5323
5324 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5325 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5326 if (array_ptr == array_ref) {
5327 ZVAL_NEW_REF(array_ref, array_ref);
5328 array_ptr = Z_REFVAL_P(array_ref);
5329 }
5330 Z_ADDREF_P(array_ref);
5331 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5332 } else {
5333 array_ref = EX_VAR(opline->result.var);
5334 ZVAL_NEW_REF(array_ref, array_ptr);
5335 array_ptr = Z_REFVAL_P(array_ref);
5336 }
5337 if (IS_CONST == IS_CONST) {
5338 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
5339 } else {
5340 SEPARATE_ARRAY(array_ptr);
5341 }
5342 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
5343
5344 ZEND_VM_NEXT_OPCODE();
5345 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5346 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
5347 HashTable *properties;
5348 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5349 if (array_ptr == array_ref) {
5350 ZVAL_NEW_REF(array_ref, array_ref);
5351 array_ptr = Z_REFVAL_P(array_ref);
5352 }
5353 Z_ADDREF_P(array_ref);
5354 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5355 } else {
5356 array_ptr = EX_VAR(opline->result.var);
5357 ZVAL_COPY_VALUE(array_ptr, array_ref);
5358 }
5359 if (Z_OBJ_P(array_ptr)->properties
5360 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
5361 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
5362 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
5363 }
5364 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
5365 }
5366
5367 properties = Z_OBJPROP_P(array_ptr);
5368 if (zend_hash_num_elements(properties) == 0) {
5369 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
5370
5371 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5372 }
5373
5374 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
5375
5376 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5377 } else {
5378 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
5379
5380 if (UNEXPECTED(EG(exception))) {
5381 HANDLE_EXCEPTION();
5382 } else if (is_empty) {
5383 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5384 } else {
5385 ZEND_VM_NEXT_OPCODE();
5386 }
5387 }
5388 } else {
5389 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
5390 ZVAL_UNDEF(EX_VAR(opline->result.var));
5391 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5392
5393 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5394 }
5395 }
5396
ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5397 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5398 {
5399 USE_OPLINE
5400 zval *value;
5401 zend_reference *ref = NULL;
5402 bool ret;
5403
5404 SAVE_OPLINE();
5405 value = RT_CONSTANT(opline, opline->op1);
5406
5407 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && Z_ISREF_P(value)) {
5408 if (IS_CONST == IS_VAR) {
5409 ref = Z_REF_P(value);
5410 }
5411 value = Z_REFVAL_P(value);
5412 }
5413
5414 ret = i_zend_is_true(value);
5415
5416 if (UNEXPECTED(EG(exception))) {
5417
5418 ZVAL_UNDEF(EX_VAR(opline->result.var));
5419 HANDLE_EXCEPTION();
5420 }
5421
5422 if (ret) {
5423 zval *result = EX_VAR(opline->result.var);
5424
5425 ZVAL_COPY_VALUE(result, value);
5426 if (IS_CONST == IS_CONST) {
5427 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5428 } else if (IS_CONST == IS_CV) {
5429 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5430 } else if (IS_CONST == IS_VAR && ref) {
5431 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5432 efree_size(ref, sizeof(zend_reference));
5433 } else if (Z_OPT_REFCOUNTED_P(result)) {
5434 Z_ADDREF_P(result);
5435 }
5436 }
5437 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5438 }
5439
5440 ZEND_VM_NEXT_OPCODE();
5441 }
5442
ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5443 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5444 {
5445 USE_OPLINE
5446 zval *value;
5447 zend_reference *ref = NULL;
5448
5449 SAVE_OPLINE();
5450 value = RT_CONSTANT(opline, opline->op1);
5451
5452 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
5453 if (IS_CONST & IS_VAR) {
5454 ref = Z_REF_P(value);
5455 }
5456 value = Z_REFVAL_P(value);
5457 }
5458
5459 if (Z_TYPE_P(value) > IS_NULL) {
5460 zval *result = EX_VAR(opline->result.var);
5461 ZVAL_COPY_VALUE(result, value);
5462 if (IS_CONST == IS_CONST) {
5463 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5464 } else if (IS_CONST == IS_CV) {
5465 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5466 } else if ((IS_CONST & IS_VAR) && ref) {
5467 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5468 efree_size(ref, sizeof(zend_reference));
5469 } else if (Z_OPT_REFCOUNTED_P(result)) {
5470 Z_ADDREF_P(result);
5471 }
5472 }
5473 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5474 }
5475
5476 if ((IS_CONST & IS_VAR) && ref) {
5477 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5478 efree_size(ref, sizeof(zend_reference));
5479 }
5480 }
5481 ZEND_VM_NEXT_OPCODE();
5482 }
5483
ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5484 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5485 {
5486 USE_OPLINE
5487 zval *val, *result;
5488
5489 val = RT_CONSTANT(opline, opline->op1);
5490
5491 if (Z_TYPE_P(val) > IS_NULL) {
5492 do {
5493 if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
5494 val = Z_REFVAL_P(val);
5495 if (Z_TYPE_P(val) <= IS_NULL) {
5496
5497 break;
5498 }
5499 }
5500 ZEND_VM_NEXT_OPCODE();
5501 } while (0);
5502 }
5503
5504 result = EX_VAR(opline->result.var);
5505 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
5506 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
5507 ZVAL_NULL(result);
5508 if (IS_CONST == IS_CV
5509 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
5510 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
5511 ) {
5512 SAVE_OPLINE();
5513 ZVAL_UNDEFINED_OP1();
5514 if (UNEXPECTED(EG(exception) != NULL)) {
5515 HANDLE_EXCEPTION();
5516 }
5517 }
5518 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
5519 ZVAL_FALSE(result);
5520 } else {
5521 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
5522 ZVAL_TRUE(result);
5523 }
5524
5525 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5526 }
5527
ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5528 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5529 {
5530 USE_OPLINE
5531 zval *value;
5532 zval *result = EX_VAR(opline->result.var);
5533
5534 value = RT_CONSTANT(opline, opline->op1);
5535 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5536 SAVE_OPLINE();
5537 ZVAL_UNDEFINED_OP1();
5538 ZVAL_NULL(result);
5539 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5540 }
5541
5542 if (IS_CONST == IS_CV) {
5543 ZVAL_COPY_DEREF(result, value);
5544 } else if (IS_CONST == IS_VAR) {
5545 if (UNEXPECTED(Z_ISREF_P(value))) {
5546 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
5547 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
5548 efree_size(Z_REF_P(value), sizeof(zend_reference));
5549 } else if (Z_OPT_REFCOUNTED_P(result)) {
5550 Z_ADDREF_P(result);
5551 }
5552 } else {
5553 ZVAL_COPY_VALUE(result, value);
5554 }
5555 } else {
5556 ZVAL_COPY_VALUE(result, value);
5557 if (IS_CONST == IS_CONST) {
5558 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
5559 Z_ADDREF_P(result);
5560 }
5561 }
5562 }
5563 ZEND_VM_NEXT_OPCODE();
5564 }
5565
ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5566 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5567 {
5568 USE_OPLINE
5569
5570 SAVE_OPLINE();
5571 do_bind_class(RT_CONSTANT(opline, opline->op1), (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL);
5572 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5573 }
5574
ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5575 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5576 {
5577 USE_OPLINE
5578 zend_function *func;
5579 zval *object;
5580 zend_class_entry *called_scope;
5581
5582 func = (zend_function *) EX(func)->op_array.dynamic_func_defs[opline->op2.num];
5583 if (Z_TYPE(EX(This)) == IS_OBJECT) {
5584 called_scope = Z_OBJCE(EX(This));
5585 if (UNEXPECTED((func->common.fn_flags & ZEND_ACC_STATIC) ||
5586 (EX(func)->common.fn_flags & ZEND_ACC_STATIC))) {
5587 object = NULL;
5588 } else {
5589 object = &EX(This);
5590 }
5591 } else {
5592 called_scope = Z_CE(EX(This));
5593 object = NULL;
5594 }
5595 SAVE_OPLINE();
5596 zend_create_closure(EX_VAR(opline->result.var), func,
5597 EX(func)->op_array.scope, called_scope, object);
5598
5599 ZEND_VM_NEXT_OPCODE();
5600 }
5601
ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5602 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5603 {
5604 USE_OPLINE
5605 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
5606 zval *val;
5607
5608 SAVE_OPLINE();
5609 val = RT_CONSTANT(opline, opline->op1);
5610
5611 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
5612 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
5613
5614 UNDEF_RESULT();
5615 HANDLE_EXCEPTION();
5616 }
5617
5618 yield_from_try_again:
5619 if (Z_TYPE_P(val) == IS_ARRAY) {
5620 ZVAL_COPY_VALUE(&generator->values, val);
5621 if (Z_OPT_REFCOUNTED_P(val)) {
5622 Z_ADDREF_P(val);
5623 }
5624 Z_FE_POS(generator->values) = 0;
5625
5626 } else if (IS_CONST != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
5627 zend_class_entry *ce = Z_OBJCE_P(val);
5628 if (ce == zend_ce_generator) {
5629 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
5630
5631 Z_ADDREF_P(val);
5632
5633 if (UNEXPECTED(new_gen->execute_data == NULL)) {
5634 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
5635 zval_ptr_dtor(val);
5636 UNDEF_RESULT();
5637 HANDLE_EXCEPTION();
5638 } else if (Z_ISUNDEF(new_gen->retval)) {
5639 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
5640 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
5641 zval_ptr_dtor(val);
5642 UNDEF_RESULT();
5643 HANDLE_EXCEPTION();
5644 } else {
5645 zend_generator_yield_from(generator, new_gen);
5646 }
5647 } else {
5648 if (RETURN_VALUE_USED(opline)) {
5649 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
5650 }
5651 ZEND_VM_NEXT_OPCODE();
5652 }
5653 } else {
5654 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
5655
5656 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
5657 if (!EG(exception)) {
5658 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
5659 }
5660 UNDEF_RESULT();
5661 HANDLE_EXCEPTION();
5662 }
5663
5664 iter->index = 0;
5665 if (iter->funcs->rewind) {
5666 iter->funcs->rewind(iter);
5667 if (UNEXPECTED(EG(exception) != NULL)) {
5668 OBJ_RELEASE(&iter->std);
5669 UNDEF_RESULT();
5670 HANDLE_EXCEPTION();
5671 }
5672 }
5673
5674 ZVAL_OBJ(&generator->values, &iter->std);
5675 }
5676 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
5677 val = Z_REFVAL_P(val);
5678 goto yield_from_try_again;
5679 } else {
5680 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
5681
5682 UNDEF_RESULT();
5683 HANDLE_EXCEPTION();
5684 }
5685
5686 /* This is the default return value
5687 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
5688 if (RETURN_VALUE_USED(opline)) {
5689 ZVAL_NULL(EX_VAR(opline->result.var));
5690 }
5691
5692 /* This generator has no send target (though the generator we delegate to might have one) */
5693 generator->send_target = NULL;
5694
5695 /* We increment to the next op, so we are at the correct position when the
5696 * generator is resumed. */
5697 ZEND_VM_INC_OPCODE();
5698
5699 /* The GOTO VM uses a local opline variable. We need to set the opline
5700 * variable in execute_data so we don't resume at an old position. */
5701 SAVE_OPLINE();
5702
5703 ZEND_VM_RETURN();
5704 }
5705
ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5706 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5707 {
5708 USE_OPLINE
5709 zval *value;
5710
5711 value = RT_CONSTANT(opline, opline->op1);
5712 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
5713 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
5714 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
5715 zval_ptr_dtor_str(value);
5716 }
5717 ZEND_VM_NEXT_OPCODE();
5718 } else {
5719 bool strict;
5720
5721 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
5722 value = Z_REFVAL_P(value);
5723 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
5724 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
5725
5726 ZEND_VM_NEXT_OPCODE();
5727 }
5728 }
5729
5730 SAVE_OPLINE();
5731 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5732 value = ZVAL_UNDEFINED_OP1();
5733 }
5734 strict = EX_USES_STRICT_TYPES();
5735 do {
5736 if (EXPECTED(!strict)) {
5737 zend_string *str;
5738 zval tmp;
5739
5740 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
5741 zend_error(E_DEPRECATED,
5742 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
5743 ZVAL_LONG(EX_VAR(opline->result.var), 0);
5744 if (UNEXPECTED(EG(exception))) {
5745 HANDLE_EXCEPTION();
5746 }
5747 break;
5748 }
5749
5750 ZVAL_COPY(&tmp, value);
5751 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
5752 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
5753 zval_ptr_dtor(&tmp);
5754 break;
5755 }
5756 zval_ptr_dtor(&tmp);
5757 }
5758 if (!EG(exception)) {
5759 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
5760 }
5761 ZVAL_UNDEF(EX_VAR(opline->result.var));
5762 } while (0);
5763 }
5764
5765 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5766 }
5767
ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5768 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5769 {
5770 USE_OPLINE
5771 zval *value;
5772 int result = 0;
5773
5774 value = RT_CONSTANT(opline, opline->op1);
5775 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
5776 type_check_resource:
5777 if (opline->extended_value != MAY_BE_RESOURCE
5778 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
5779 result = 1;
5780 }
5781 } else if ((IS_CONST & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
5782 value = Z_REFVAL_P(value);
5783 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
5784 goto type_check_resource;
5785 }
5786 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5787 result = ((1 << IS_NULL) & opline->extended_value) != 0;
5788 SAVE_OPLINE();
5789 ZVAL_UNDEFINED_OP1();
5790 if (UNEXPECTED(EG(exception))) {
5791 ZVAL_UNDEF(EX_VAR(opline->result.var));
5792 HANDLE_EXCEPTION();
5793 }
5794 }
5795 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
5796 SAVE_OPLINE();
5797
5798 ZEND_VM_SMART_BRANCH(result, 1);
5799 } else {
5800 ZEND_VM_SMART_BRANCH(result, 0);
5801 }
5802 }
5803
ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5804 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5805 {
5806 USE_OPLINE
5807 zend_constant *c;
5808
5809 c = CACHED_PTR(opline->extended_value);
5810 if (EXPECTED(c != NULL)) {
5811 if (!IS_SPECIAL_CACHE_VAL(c)) {
5812 defined_true:
5813 ZEND_VM_SMART_BRANCH_TRUE();
5814 } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
5815 defined_false:
5816 ZEND_VM_SMART_BRANCH_FALSE();
5817 }
5818 }
5819 if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
5820 CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants))));
5821 goto defined_false;
5822 } else {
5823 goto defined_true;
5824 }
5825 }
5826
ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5827 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5828 {
5829 USE_OPLINE
5830 zend_jmp_fl_result result = (uintptr_t)CACHED_PTR(opline->extended_value);
5831 try_again:
5832 if (EXPECTED(result == ZEND_JMP_FL_HIT)) {
5833 OPLINE = OP_JMP_ADDR(opline, opline->op2);
5834 ZEND_VM_CONTINUE();
5835 } else if (EXPECTED(result == ZEND_JMP_FL_MISS)) {
5836 ZEND_VM_NEXT_OPCODE();
5837 } else {
5838 ZEND_ASSERT(result == ZEND_JMP_FL_UNPRIMED);
5839 /* func_name refers to the function in the local namespace, e.g. foo\substr. */
5840 zval *func_name = (zval *)RT_CONSTANT(opline, opline->op1);
5841 /* If it cannot be found locally, we must be referring to the global function. */
5842 zval *func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name));
5843 /* ZEND_JMP_FL_MISS = 1, ZEND_JMP_FL_HIT = 2 */
5844 result = (func == NULL) + 1;
5845 CACHE_PTR(opline->extended_value, (void *)result);
5846 goto try_again;
5847 }
5848 }
5849
ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5850 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5851 {
5852 USE_OPLINE
5853 zval *value;
5854
5855 value = RT_CONSTANT(opline, opline->op1);
5856 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
5857 ZEND_VM_NEXT_OPCODE();
5858 }
5859
ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5860 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5861 {
5862 USE_OPLINE
5863 zval *value;
5864
5865 value = RT_CONSTANT(opline, opline->op1);
5866 ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
5867 ZEND_VM_NEXT_OPCODE();
5868 }
5869
ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5870 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5871 {
5872 USE_OPLINE
5873 zval *value;
5874
5875 value = RT_CONSTANT(opline, opline->op1);
5876 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
5877 ZEND_VM_NEXT_OPCODE();
5878 }
5879
ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5880 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5881 {
5882 USE_OPLINE
5883 zval *value, *arg;
5884
5885 value = RT_CONSTANT(opline, opline->op1);
5886 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
5887 ZVAL_COPY_VALUE(arg, value);
5888 ZEND_VM_NEXT_OPCODE();
5889 }
5890
ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5891 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5892 {
5893 USE_OPLINE
5894 zval *value, *arg;
5895 uint32_t arg_num = opline->op2.num;
5896
5897 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
5898 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
5899 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
5900 }
5901 value = RT_CONSTANT(opline, opline->op1);
5902 ZVAL_COPY_VALUE(arg, value);
5903 ZEND_VM_NEXT_OPCODE();
5904 }
5905
ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5906 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5907 {
5908 USE_OPLINE
5909 zval *op1, *op2, *result;
5910 double d1, d2;
5911
5912 op1 = RT_CONSTANT(opline, opline->op1);
5913 op2 = RT_CONSTANT(opline, opline->op2);
5914 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
5915 /* pass */
5916 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
5917 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5918 result = EX_VAR(opline->result.var);
5919 fast_long_add_function(result, op1, op2);
5920 ZEND_VM_NEXT_OPCODE();
5921 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
5922 d1 = (double)Z_LVAL_P(op1);
5923 d2 = Z_DVAL_P(op2);
5924 goto add_double;
5925 }
5926 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
5927 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
5928 d1 = Z_DVAL_P(op1);
5929 d2 = Z_DVAL_P(op2);
5930 add_double:
5931 result = EX_VAR(opline->result.var);
5932 ZVAL_DOUBLE(result, d1 + d2);
5933 ZEND_VM_NEXT_OPCODE();
5934 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5935 d1 = Z_DVAL_P(op1);
5936 d2 = (double)Z_LVAL_P(op2);
5937 goto add_double;
5938 }
5939 }
5940
5941 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
5942 }
5943
ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5944 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5945 {
5946 USE_OPLINE
5947 zval *op1, *op2, *result;
5948 double d1, d2;
5949
5950 op1 = RT_CONSTANT(opline, opline->op1);
5951 op2 = RT_CONSTANT(opline, opline->op2);
5952 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
5953 /* pass */
5954 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
5955 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5956 result = EX_VAR(opline->result.var);
5957 fast_long_sub_function(result, op1, op2);
5958 ZEND_VM_NEXT_OPCODE();
5959 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
5960 d1 = (double)Z_LVAL_P(op1);
5961 d2 = Z_DVAL_P(op2);
5962 goto sub_double;
5963 }
5964 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
5965 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
5966 d1 = Z_DVAL_P(op1);
5967 d2 = Z_DVAL_P(op2);
5968 sub_double:
5969 result = EX_VAR(opline->result.var);
5970 ZVAL_DOUBLE(result, d1 - d2);
5971 ZEND_VM_NEXT_OPCODE();
5972 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5973 d1 = Z_DVAL_P(op1);
5974 d2 = (double)Z_LVAL_P(op2);
5975 goto sub_double;
5976 }
5977 }
5978
5979 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
5980 }
5981
ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5982 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5983 {
5984 USE_OPLINE
5985 zval *op1, *op2, *result;
5986 double d1, d2;
5987
5988 op1 = RT_CONSTANT(opline, opline->op1);
5989 op2 = RT_CONSTANT(opline, opline->op2);
5990 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
5991 /* pass */
5992 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
5993 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5994 zend_long overflow;
5995
5996 result = EX_VAR(opline->result.var);
5997 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
5998 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
5999 ZEND_VM_NEXT_OPCODE();
6000 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6001 d1 = (double)Z_LVAL_P(op1);
6002 d2 = Z_DVAL_P(op2);
6003 goto mul_double;
6004 }
6005 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6006 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6007 d1 = Z_DVAL_P(op1);
6008 d2 = Z_DVAL_P(op2);
6009 mul_double:
6010 result = EX_VAR(opline->result.var);
6011 ZVAL_DOUBLE(result, d1 * d2);
6012 ZEND_VM_NEXT_OPCODE();
6013 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6014 d1 = Z_DVAL_P(op1);
6015 d2 = (double)Z_LVAL_P(op2);
6016 goto mul_double;
6017 }
6018 }
6019
6020 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6021 }
6022
ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6023 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6024 {
6025 USE_OPLINE
6026 zval *op1, *op2;
6027
6028 SAVE_OPLINE();
6029 op1 = RT_CONSTANT(opline, opline->op1);
6030 op2 = RT_CONSTANT(opline, opline->op2);
6031 div_function(EX_VAR(opline->result.var), op1, op2);
6032
6033
6034 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6035 }
6036
ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6037 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6038 {
6039 USE_OPLINE
6040 zval *op1, *op2, *result;
6041
6042 op1 = RT_CONSTANT(opline, opline->op1);
6043 op2 = RT_CONSTANT(opline, opline->op2);
6044 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6045 /* pass */
6046 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6047 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6048 result = EX_VAR(opline->result.var);
6049 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
6050 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6051 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
6052 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
6053 ZVAL_LONG(result, 0);
6054 } else {
6055 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
6056 }
6057 ZEND_VM_NEXT_OPCODE();
6058 }
6059 }
6060
6061 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6062 }
6063
ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6064 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6065 {
6066 USE_OPLINE
6067 zval *op1, *op2;
6068
6069 op1 = RT_CONSTANT(opline, opline->op1);
6070 op2 = RT_CONSTANT(opline, opline->op2);
6071 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6072 /* pass */
6073 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6074 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
6075 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
6076 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
6077 ZVAL_LONG(EX_VAR(opline->result.var),
6078 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
6079 ZEND_VM_NEXT_OPCODE();
6080 }
6081
6082 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6083 }
6084
ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6085 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6086 {
6087 USE_OPLINE
6088 zval *op1, *op2;
6089
6090 op1 = RT_CONSTANT(opline, opline->op1);
6091 op2 = RT_CONSTANT(opline, opline->op2);
6092 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6093 /* pass */
6094 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6095 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
6096 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
6097 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
6098 ZEND_VM_NEXT_OPCODE();
6099 }
6100
6101 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6102 }
6103
ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6104 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6105 {
6106 USE_OPLINE
6107 zval *op1, *op2;
6108
6109 SAVE_OPLINE();
6110 op1 = RT_CONSTANT(opline, opline->op1);
6111 op2 = RT_CONSTANT(opline, opline->op2);
6112 pow_function(EX_VAR(opline->result.var), op1, op2);
6113
6114
6115 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6116 }
6117
ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6118 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6119 {
6120 USE_OPLINE
6121 zval *op1, *op2;
6122 bool result;
6123
6124 SAVE_OPLINE();
6125 op1 = RT_CONSTANT(opline, opline->op1);
6126 op2 = RT_CONSTANT(opline, opline->op2);
6127 result = fast_is_identical_function(op1, op2);
6128
6129
6130 ZEND_VM_SMART_BRANCH(result, 1);
6131 }
6132
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6133 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6134 {
6135 USE_OPLINE
6136 zval *op1, *op2;
6137 bool result;
6138
6139 SAVE_OPLINE();
6140 op1 = RT_CONSTANT(opline, opline->op1);
6141 op2 = RT_CONSTANT(opline, opline->op2);
6142 result = fast_is_not_identical_function(op1, op2);
6143
6144
6145 ZEND_VM_SMART_BRANCH(result, 1);
6146 }
6147
ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6148 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6149 {
6150 USE_OPLINE
6151 zval *op1, *op2;
6152 double d1, d2;
6153
6154 op1 = RT_CONSTANT(opline, opline->op1);
6155 op2 = RT_CONSTANT(opline, opline->op2);
6156 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6157 /* pass */
6158 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
6159 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6160 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
6161 is_equal_true:
6162 ZEND_VM_SMART_BRANCH_TRUE();
6163 } else {
6164 is_equal_false:
6165 ZEND_VM_SMART_BRANCH_FALSE();
6166 }
6167 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6168 d1 = (double)Z_LVAL_P(op1);
6169 d2 = Z_DVAL_P(op2);
6170 goto is_equal_double;
6171 }
6172 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
6173 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6174 d1 = Z_DVAL_P(op1);
6175 d2 = Z_DVAL_P(op2);
6176 is_equal_double:
6177 if (d1 == d2) {
6178 goto is_equal_true;
6179 } else {
6180 goto is_equal_false;
6181 }
6182 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6183 d1 = Z_DVAL_P(op1);
6184 d2 = (double)Z_LVAL_P(op2);
6185 goto is_equal_double;
6186 }
6187 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6188 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6189 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
6190 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6191 zval_ptr_dtor_str(op1);
6192 }
6193 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6194 zval_ptr_dtor_str(op2);
6195 }
6196 if (result) {
6197 goto is_equal_true;
6198 } else {
6199 goto is_equal_false;
6200 }
6201 }
6202 }
6203 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6204 }
6205
ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6206 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6207 {
6208 USE_OPLINE
6209 zval *op1, *op2;
6210 double d1, d2;
6211
6212 op1 = RT_CONSTANT(opline, opline->op1);
6213 op2 = RT_CONSTANT(opline, opline->op2);
6214 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6215 /* pass */
6216 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
6217 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6218 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
6219 is_not_equal_true:
6220 ZEND_VM_SMART_BRANCH_TRUE();
6221 } else {
6222 is_not_equal_false:
6223 ZEND_VM_SMART_BRANCH_FALSE();
6224 }
6225 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6226 d1 = (double)Z_LVAL_P(op1);
6227 d2 = Z_DVAL_P(op2);
6228 goto is_not_equal_double;
6229 }
6230 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
6231 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6232 d1 = Z_DVAL_P(op1);
6233 d2 = Z_DVAL_P(op2);
6234 is_not_equal_double:
6235 if (d1 != d2) {
6236 goto is_not_equal_true;
6237 } else {
6238 goto is_not_equal_false;
6239 }
6240 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6241 d1 = Z_DVAL_P(op1);
6242 d2 = (double)Z_LVAL_P(op2);
6243 goto is_not_equal_double;
6244 }
6245 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6246 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6247 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
6248 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6249 zval_ptr_dtor_str(op1);
6250 }
6251 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6252 zval_ptr_dtor_str(op2);
6253 }
6254 if (!result) {
6255 goto is_not_equal_true;
6256 } else {
6257 goto is_not_equal_false;
6258 }
6259 }
6260 }
6261 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6262 }
6263
ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6264 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6265 {
6266 USE_OPLINE
6267 zval *op1, *op2;
6268 double d1, d2;
6269
6270 op1 = RT_CONSTANT(opline, opline->op1);
6271 op2 = RT_CONSTANT(opline, opline->op2);
6272 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6273 /* pass */
6274 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6275 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6276 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
6277 is_smaller_true:
6278 ZEND_VM_SMART_BRANCH_TRUE();
6279 } else {
6280 is_smaller_false:
6281 ZEND_VM_SMART_BRANCH_FALSE();
6282 }
6283 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6284 d1 = (double)Z_LVAL_P(op1);
6285 d2 = Z_DVAL_P(op2);
6286 goto is_smaller_double;
6287 }
6288 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6289 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6290 d1 = Z_DVAL_P(op1);
6291 d2 = Z_DVAL_P(op2);
6292 is_smaller_double:
6293 if (d1 < d2) {
6294 goto is_smaller_true;
6295 } else {
6296 goto is_smaller_false;
6297 }
6298 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6299 d1 = Z_DVAL_P(op1);
6300 d2 = (double)Z_LVAL_P(op2);
6301 goto is_smaller_double;
6302 }
6303 }
6304 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6305 }
6306
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6307 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6308 {
6309 USE_OPLINE
6310 zval *op1, *op2;
6311 double d1, d2;
6312
6313 op1 = RT_CONSTANT(opline, opline->op1);
6314 op2 = RT_CONSTANT(opline, opline->op2);
6315 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6316 /* pass */
6317 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6318 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6319 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
6320 is_smaller_or_equal_true:
6321 ZEND_VM_SMART_BRANCH_TRUE();
6322 ZVAL_TRUE(EX_VAR(opline->result.var));
6323 ZEND_VM_NEXT_OPCODE();
6324 } else {
6325 is_smaller_or_equal_false:
6326 ZEND_VM_SMART_BRANCH_FALSE();
6327 ZVAL_FALSE(EX_VAR(opline->result.var));
6328 ZEND_VM_NEXT_OPCODE();
6329 }
6330 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6331 d1 = (double)Z_LVAL_P(op1);
6332 d2 = Z_DVAL_P(op2);
6333 goto is_smaller_or_equal_double;
6334 }
6335 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6336 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6337 d1 = Z_DVAL_P(op1);
6338 d2 = Z_DVAL_P(op2);
6339 is_smaller_or_equal_double:
6340 if (d1 <= d2) {
6341 goto is_smaller_or_equal_true;
6342 } else {
6343 goto is_smaller_or_equal_false;
6344 }
6345 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6346 d1 = Z_DVAL_P(op1);
6347 d2 = (double)Z_LVAL_P(op2);
6348 goto is_smaller_or_equal_double;
6349 }
6350 }
6351 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6352 }
6353
ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6354 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6355 {
6356 USE_OPLINE
6357 zval *op1, *op2;
6358
6359 SAVE_OPLINE();
6360 op1 = RT_CONSTANT(opline, opline->op1);
6361 op2 = RT_CONSTANT(opline, opline->op2);
6362 compare_function(EX_VAR(opline->result.var), op1, op2);
6363
6364
6365 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6366 }
6367
ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6368 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_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_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6384 }
6385
ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6386 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_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_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6402 }
6403
ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6404 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6405 {
6406 USE_OPLINE
6407 zval *op1, *op2;
6408
6409 op1 = RT_CONSTANT(opline, opline->op1);
6410 op2 = RT_CONSTANT(opline, opline->op2);
6411 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6412 /* pass */
6413 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6414 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6415 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
6416 ZEND_VM_NEXT_OPCODE();
6417 }
6418
6419 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6420 }
6421
ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6422 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6423 {
6424 USE_OPLINE
6425 zval *op1, *op2;
6426
6427 SAVE_OPLINE();
6428 op1 = RT_CONSTANT(opline, opline->op1);
6429 op2 = RT_CONSTANT(opline, opline->op2);
6430 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
6431
6432
6433 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6434 }
6435
ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6436 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6437 {
6438 USE_OPLINE
6439 zval *container, *dim, *value;
6440
6441 SAVE_OPLINE();
6442 container = RT_CONSTANT(opline, opline->op1);
6443 dim = RT_CONSTANT(opline, opline->op2);
6444 if (IS_CONST != IS_CONST) {
6445 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6446 fetch_dim_r_array:
6447 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
6448 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
6449 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
6450 container = Z_REFVAL_P(container);
6451 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6452 goto fetch_dim_r_array;
6453 } else {
6454 goto fetch_dim_r_slow;
6455 }
6456 } else {
6457 fetch_dim_r_slow:
6458 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
6459 dim++;
6460 }
6461 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
6462 }
6463 } else {
6464 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6465 }
6466
6467
6468 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6469 }
6470
ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6471 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6472 {
6473 USE_OPLINE
6474 zval *container;
6475
6476 SAVE_OPLINE();
6477 container = RT_CONSTANT(opline, opline->op1);
6478 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6479
6480
6481 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6482 }
6483
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6484 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6485 {
6486 #if 0
6487 USE_OPLINE
6488 #endif
6489
6490 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
6491 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
6492 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6493 }
6494 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6495 } else {
6496 if (IS_CONST == IS_UNUSED) {
6497 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6498 }
6499 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6500 }
6501 }
6502
ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6503 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6504 {
6505 USE_OPLINE
6506 zval *container;
6507 void **cache_slot = NULL;
6508
6509 SAVE_OPLINE();
6510 container = RT_CONSTANT(opline, opline->op1);
6511
6512 if (IS_CONST == IS_CONST ||
6513 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6514 do {
6515 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6516 container = Z_REFVAL_P(container);
6517 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
6518 break;
6519 }
6520 }
6521 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
6522 ZVAL_UNDEFINED_OP1();
6523 }
6524 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
6525 ZVAL_NULL(EX_VAR(opline->result.var));
6526 goto fetch_obj_r_finish;
6527 } while (0);
6528 }
6529
6530 /* here we are sure we are dealing with an object */
6531 do {
6532 zend_object *zobj = Z_OBJ_P(container);
6533 zend_string *name, *tmp_name;
6534 zval *retval;
6535
6536 if (IS_CONST == IS_CONST) {
6537 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
6538
6539 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
6540 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
6541
6542 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
6543 retval = OBJ_PROP(zobj, prop_offset);
6544 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
6545 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6546 goto fetch_obj_r_copy;
6547 } else {
6548 fetch_obj_r_fast_copy:
6549 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6550 ZEND_VM_NEXT_OPCODE();
6551 }
6552 }
6553 } else if (EXPECTED(zobj->properties != NULL)) {
6554 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6555 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
6556 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
6557
6558 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
6559 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
6560
6561 if (EXPECTED(p->key == name) ||
6562 (EXPECTED(p->h == ZSTR_H(name)) &&
6563 EXPECTED(p->key != NULL) &&
6564 EXPECTED(zend_string_equal_content(p->key, name)))) {
6565 retval = &p->val;
6566 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6567 goto fetch_obj_r_copy;
6568 } else {
6569 goto fetch_obj_r_fast_copy;
6570 }
6571 }
6572 }
6573 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
6574 }
6575 retval = zend_hash_find_known_hash(zobj->properties, name);
6576 if (EXPECTED(retval)) {
6577 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
6578 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
6579 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6580 goto fetch_obj_r_copy;
6581 } else {
6582 goto fetch_obj_r_fast_copy;
6583 }
6584 }
6585 }
6586 }
6587 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6588 } else {
6589 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
6590 if (UNEXPECTED(!name)) {
6591 ZVAL_UNDEF(EX_VAR(opline->result.var));
6592 break;
6593 }
6594 }
6595
6596 #if ZEND_DEBUG
6597 /* For non-standard object handlers, verify a declared property type in debug builds.
6598 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
6599 zend_property_info *prop_info = NULL;
6600 if (zobj->handlers->read_property != zend_std_read_property) {
6601 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
6602 }
6603 #endif
6604 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
6605 #if ZEND_DEBUG
6606 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
6607 && ZEND_TYPE_IS_SET(prop_info->type)) {
6608 ZVAL_OPT_DEREF(retval);
6609 zend_verify_property_type(prop_info, retval, /* strict */ true);
6610 }
6611 #endif
6612
6613 if (IS_CONST != IS_CONST) {
6614 zend_tmp_string_release(tmp_name);
6615 }
6616
6617 if (retval != EX_VAR(opline->result.var)) {
6618 fetch_obj_r_copy:
6619 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6620 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
6621 zend_unwrap_reference(retval);
6622 }
6623 } while (0);
6624
6625 fetch_obj_r_finish:
6626
6627
6628 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6629 }
6630
ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6631 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6632 {
6633 USE_OPLINE
6634 zval *container;
6635 void **cache_slot = NULL;
6636
6637 SAVE_OPLINE();
6638 container = RT_CONSTANT(opline, opline->op1);
6639
6640 if (IS_CONST == IS_CONST ||
6641 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6642 do {
6643 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6644 container = Z_REFVAL_P(container);
6645 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
6646 break;
6647 }
6648 }
6649 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
6650 ZVAL_UNDEFINED_OP2();
6651 }
6652 ZVAL_NULL(EX_VAR(opline->result.var));
6653 goto fetch_obj_is_finish;
6654 } while (0);
6655 }
6656
6657 /* here we are sure we are dealing with an object */
6658 do {
6659 zend_object *zobj = Z_OBJ_P(container);
6660 zend_string *name, *tmp_name;
6661 zval *retval;
6662
6663 if (IS_CONST == IS_CONST) {
6664 cache_slot = CACHE_ADDR(opline->extended_value);
6665
6666 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
6667 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
6668
6669 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
6670 retval = OBJ_PROP(zobj, prop_offset);
6671 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
6672 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6673 goto fetch_obj_is_copy;
6674 } else {
6675 fetch_obj_is_fast_copy:
6676 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6677 ZEND_VM_NEXT_OPCODE();
6678 }
6679 }
6680 } else if (EXPECTED(zobj->properties != NULL)) {
6681 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6682 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
6683 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
6684
6685 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
6686 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
6687
6688 if (EXPECTED(p->key == name) ||
6689 (EXPECTED(p->h == ZSTR_H(name)) &&
6690 EXPECTED(p->key != NULL) &&
6691 EXPECTED(zend_string_equal_content(p->key, name)))) {
6692 retval = &p->val;
6693 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6694 goto fetch_obj_is_copy;
6695 } else {
6696 goto fetch_obj_is_fast_copy;
6697 }
6698 }
6699 }
6700 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
6701 }
6702 retval = zend_hash_find_known_hash(zobj->properties, name);
6703 if (EXPECTED(retval)) {
6704 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
6705 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
6706 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6707 goto fetch_obj_is_copy;
6708 } else {
6709 goto fetch_obj_is_fast_copy;
6710 }
6711 }
6712 }
6713 }
6714 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6715 } else {
6716 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
6717 if (UNEXPECTED(!name)) {
6718 ZVAL_UNDEF(EX_VAR(opline->result.var));
6719 break;
6720 }
6721 }
6722
6723 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
6724
6725 if (IS_CONST != IS_CONST) {
6726 zend_tmp_string_release(tmp_name);
6727 }
6728
6729 if (retval != EX_VAR(opline->result.var)) {
6730 fetch_obj_is_copy:
6731 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6732 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
6733 zend_unwrap_reference(retval);
6734 }
6735 } while (0);
6736
6737 fetch_obj_is_finish:
6738
6739
6740 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6741 }
6742
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6743 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6744 {
6745 #if 0
6746 USE_OPLINE
6747 #endif
6748
6749 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
6750 /* Behave like FETCH_OBJ_W */
6751 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
6752 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6753 }
6754 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6755 } else {
6756 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6757 }
6758 }
6759
ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6760 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6761 {
6762 USE_OPLINE
6763 zval *container;
6764
6765 SAVE_OPLINE();
6766 container = RT_CONSTANT(opline, opline->op1);
6767 zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6768
6769 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6770 }
6771
ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6772 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6773 {
6774 USE_OPLINE
6775 zval *op1, *op2;
6776 zend_string *op1_str, *op2_str, *str;
6777
6778
6779 op1 = RT_CONSTANT(opline, opline->op1);
6780 op2 = RT_CONSTANT(opline, opline->op2);
6781 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
6782 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
6783 zend_string *op1_str = Z_STR_P(op1);
6784 zend_string *op2_str = Z_STR_P(op2);
6785 zend_string *str;
6786 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
6787
6788 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
6789 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
6790 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
6791 } else {
6792 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
6793 }
6794 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6795 zend_string_release_ex(op1_str, 0);
6796 }
6797 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
6798 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
6799 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
6800 } else {
6801 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
6802 }
6803 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6804 zend_string_release_ex(op2_str, 0);
6805 }
6806 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
6807 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
6808 size_t len = ZSTR_LEN(op1_str);
6809
6810 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
6811 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
6812 GC_ADD_FLAGS(str, flags);
6813 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
6814 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6815 zend_string_release_ex(op2_str, 0);
6816 }
6817 } else {
6818 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
6819 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
6820 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
6821 GC_ADD_FLAGS(str, flags);
6822 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
6823 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6824 zend_string_release_ex(op1_str, 0);
6825 }
6826 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6827 zend_string_release_ex(op2_str, 0);
6828 }
6829 }
6830 ZEND_VM_NEXT_OPCODE();
6831 }
6832
6833 SAVE_OPLINE();
6834 if (IS_CONST == IS_CONST) {
6835 op1_str = Z_STR_P(op1);
6836 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6837 op1_str = zend_string_copy(Z_STR_P(op1));
6838 } else {
6839 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
6840 ZVAL_UNDEFINED_OP1();
6841 }
6842 op1_str = zval_get_string_func(op1);
6843 }
6844 if (IS_CONST == IS_CONST) {
6845 op2_str = Z_STR_P(op2);
6846 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6847 op2_str = zend_string_copy(Z_STR_P(op2));
6848 } else {
6849 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
6850 ZVAL_UNDEFINED_OP2();
6851 }
6852 op2_str = zval_get_string_func(op2);
6853 }
6854 do {
6855 if (IS_CONST != IS_CONST) {
6856 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
6857 if (IS_CONST == IS_CONST) {
6858 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
6859 GC_ADDREF(op2_str);
6860 }
6861 }
6862 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
6863 zend_string_release_ex(op1_str, 0);
6864 break;
6865 }
6866 }
6867 if (IS_CONST != IS_CONST) {
6868 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
6869 if (IS_CONST == IS_CONST) {
6870 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
6871 GC_ADDREF(op1_str);
6872 }
6873 }
6874 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
6875 zend_string_release_ex(op2_str, 0);
6876 break;
6877 }
6878 }
6879 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
6880 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
6881 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
6882
6883 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
6884 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
6885 if (IS_CONST != IS_CONST) {
6886 zend_string_release_ex(op1_str, 0);
6887 }
6888 if (IS_CONST != IS_CONST) {
6889 zend_string_release_ex(op2_str, 0);
6890 }
6891 } while (0);
6892
6893
6894 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6895 }
6896
ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6897 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6898 {
6899 USE_OPLINE
6900 zval *function_name;
6901 zval *object;
6902 zend_function *fbc;
6903 zend_class_entry *called_scope;
6904 zend_object *obj;
6905 zend_execute_data *call;
6906 uint32_t call_info;
6907
6908 SAVE_OPLINE();
6909
6910 object = RT_CONSTANT(opline, opline->op1);
6911
6912 if (IS_CONST != IS_CONST) {
6913 function_name = RT_CONSTANT(opline, opline->op2);
6914 }
6915
6916 if (IS_CONST != IS_CONST &&
6917 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
6918 do {
6919 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
6920 function_name = Z_REFVAL_P(function_name);
6921 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
6922 break;
6923 }
6924 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
6925 ZVAL_UNDEFINED_OP2();
6926 if (UNEXPECTED(EG(exception) != NULL)) {
6927
6928 HANDLE_EXCEPTION();
6929 }
6930 }
6931 zend_throw_error(NULL, "Method name must be a string");
6932
6933
6934 HANDLE_EXCEPTION();
6935 } while (0);
6936 }
6937
6938 if (IS_CONST == IS_UNUSED) {
6939 obj = Z_OBJ_P(object);
6940 } else {
6941 do {
6942 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
6943 obj = Z_OBJ_P(object);
6944 } else {
6945 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
6946 zend_reference *ref = Z_REF_P(object);
6947
6948 object = &ref->val;
6949 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
6950 obj = Z_OBJ_P(object);
6951 if (IS_CONST & IS_VAR) {
6952 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
6953 efree_size(ref, sizeof(zend_reference));
6954 } else {
6955 Z_ADDREF_P(object);
6956 }
6957 }
6958 break;
6959 }
6960 }
6961 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
6962 object = ZVAL_UNDEFINED_OP1();
6963 if (UNEXPECTED(EG(exception) != NULL)) {
6964 if (IS_CONST != IS_CONST) {
6965
6966 }
6967 HANDLE_EXCEPTION();
6968 }
6969 }
6970 if (IS_CONST == IS_CONST) {
6971 function_name = RT_CONSTANT(opline, opline->op2);
6972 }
6973 zend_invalid_method_call(object, function_name);
6974
6975
6976 HANDLE_EXCEPTION();
6977 }
6978 } while (0);
6979 }
6980
6981 called_scope = obj->ce;
6982
6983 if (IS_CONST == IS_CONST &&
6984 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
6985 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
6986 } else {
6987 zend_object *orig_obj = obj;
6988
6989 if (IS_CONST == IS_CONST) {
6990 function_name = RT_CONSTANT(opline, opline->op2);
6991 }
6992
6993 /* First, locate the function. */
6994 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
6995 if (UNEXPECTED(fbc == NULL)) {
6996 if (EXPECTED(!EG(exception))) {
6997 zend_undefined_method(obj->ce, Z_STR_P(function_name));
6998 }
6999
7000 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
7001 zend_objects_store_del(orig_obj);
7002 }
7003 HANDLE_EXCEPTION();
7004 }
7005 if (IS_CONST == IS_CONST &&
7006 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
7007 EXPECTED(obj == orig_obj)) {
7008 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
7009 }
7010 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
7011 GC_ADDREF(obj); /* For $this pointer */
7012 if (GC_DELREF(orig_obj) == 0) {
7013 zend_objects_store_del(orig_obj);
7014 }
7015 }
7016 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7017 init_func_run_time_cache(&fbc->op_array);
7018 }
7019 }
7020
7021 if (IS_CONST != IS_CONST) {
7022
7023 }
7024
7025 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
7026 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
7027 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
7028 zend_objects_store_del(obj);
7029 if (UNEXPECTED(EG(exception))) {
7030 HANDLE_EXCEPTION();
7031 }
7032 }
7033 /* call static method */
7034 obj = (zend_object*)called_scope;
7035 call_info = ZEND_CALL_NESTED_FUNCTION;
7036 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
7037 if (IS_CONST == IS_CV) {
7038 GC_ADDREF(obj); /* For $this pointer */
7039 }
7040 /* CV may be changed indirectly (e.g. when it's a reference) */
7041 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
7042 }
7043
7044 call = zend_vm_stack_push_call_frame(call_info,
7045 fbc, opline->extended_value, obj);
7046 call->prev_execute_data = EX(call);
7047 EX(call) = call;
7048
7049 ZEND_VM_NEXT_OPCODE();
7050 }
7051
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7052 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7053 {
7054 USE_OPLINE
7055 zval *function_name;
7056 zend_class_entry *ce;
7057 uint32_t call_info;
7058 zend_function *fbc;
7059 zend_execute_data *call;
7060
7061 SAVE_OPLINE();
7062
7063 if (IS_CONST == IS_CONST) {
7064 /* no function found. try a static method in class */
7065 ce = CACHED_PTR(opline->result.num);
7066 if (UNEXPECTED(ce == NULL)) {
7067 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);
7068 if (UNEXPECTED(ce == NULL)) {
7069
7070 HANDLE_EXCEPTION();
7071 }
7072 if (IS_CONST != IS_CONST) {
7073 CACHE_PTR(opline->result.num, ce);
7074 }
7075 }
7076 } else if (IS_CONST == IS_UNUSED) {
7077 ce = zend_fetch_class(NULL, opline->op1.num);
7078 if (UNEXPECTED(ce == NULL)) {
7079
7080 HANDLE_EXCEPTION();
7081 }
7082 } else {
7083 ce = Z_CE_P(EX_VAR(opline->op1.var));
7084 }
7085
7086 if (IS_CONST == IS_CONST &&
7087 IS_CONST == IS_CONST &&
7088 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
7089 /* nothing to do */
7090 } else if (IS_CONST != IS_CONST &&
7091 IS_CONST == IS_CONST &&
7092 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
7093 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
7094 } else if (IS_CONST != IS_UNUSED) {
7095 function_name = RT_CONSTANT(opline, opline->op2);
7096 if (IS_CONST != IS_CONST) {
7097 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
7098 do {
7099 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
7100 function_name = Z_REFVAL_P(function_name);
7101 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
7102 break;
7103 }
7104 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
7105 ZVAL_UNDEFINED_OP2();
7106 if (UNEXPECTED(EG(exception) != NULL)) {
7107 HANDLE_EXCEPTION();
7108 }
7109 }
7110 zend_throw_error(NULL, "Method name must be a string");
7111
7112 HANDLE_EXCEPTION();
7113 } while (0);
7114 }
7115 }
7116
7117 if (ce->get_static_method) {
7118 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
7119 } else {
7120 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
7121 }
7122 if (UNEXPECTED(fbc == NULL)) {
7123 if (EXPECTED(!EG(exception))) {
7124 zend_undefined_method(ce, Z_STR_P(function_name));
7125 }
7126
7127 HANDLE_EXCEPTION();
7128 }
7129 if (IS_CONST == IS_CONST &&
7130 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
7131 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
7132 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
7133 }
7134 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7135 init_func_run_time_cache(&fbc->op_array);
7136 }
7137 if (IS_CONST != IS_CONST) {
7138
7139 }
7140 } else {
7141 if (UNEXPECTED(ce->constructor == NULL)) {
7142 zend_throw_error(NULL, "Cannot call constructor");
7143 HANDLE_EXCEPTION();
7144 }
7145 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
7146 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
7147 HANDLE_EXCEPTION();
7148 }
7149 fbc = ce->constructor;
7150 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7151 init_func_run_time_cache(&fbc->op_array);
7152 }
7153 }
7154
7155 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
7156 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
7157 ce = (zend_class_entry*)Z_OBJ(EX(This));
7158 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
7159 } else {
7160 zend_non_static_method_call(fbc);
7161 HANDLE_EXCEPTION();
7162 }
7163 } else {
7164 /* previous opcode is ZEND_FETCH_CLASS */
7165 if (IS_CONST == IS_UNUSED
7166 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
7167 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
7168 if (Z_TYPE(EX(This)) == IS_OBJECT) {
7169 ce = Z_OBJCE(EX(This));
7170 } else {
7171 ce = Z_CE(EX(This));
7172 }
7173 }
7174 call_info = ZEND_CALL_NESTED_FUNCTION;
7175 }
7176
7177 call = zend_vm_stack_push_call_frame(call_info,
7178 fbc, opline->extended_value, ce);
7179 call->prev_execute_data = EX(call);
7180 EX(call) = call;
7181
7182 ZEND_VM_NEXT_OPCODE();
7183 }
7184
ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7185 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7186 {
7187 USE_OPLINE
7188 zval *function_name;
7189 zend_fcall_info_cache fcc;
7190 char *error = NULL;
7191 zend_function *func;
7192 void *object_or_called_scope;
7193 zend_execute_data *call;
7194 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
7195
7196 SAVE_OPLINE();
7197 function_name = RT_CONSTANT(opline, opline->op2);
7198 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
7199 ZEND_ASSERT(!error);
7200 func = fcc.function_handler;
7201 object_or_called_scope = fcc.called_scope;
7202 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
7203 /* Delay closure destruction until its invocation */
7204 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
7205 call_info |= ZEND_CALL_CLOSURE;
7206 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
7207 call_info |= ZEND_CALL_FAKE_CLOSURE;
7208 }
7209 if (fcc.object) {
7210 object_or_called_scope = fcc.object;
7211 call_info |= ZEND_CALL_HAS_THIS;
7212 }
7213 } else if (fcc.object) {
7214 GC_ADDREF(fcc.object); /* For $this pointer */
7215 object_or_called_scope = fcc.object;
7216 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
7217 }
7218
7219 if ((IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
7220 if (call_info & ZEND_CALL_CLOSURE) {
7221 zend_object_release(ZEND_CLOSURE_OBJECT(func));
7222 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
7223 zend_object_release(fcc.object);
7224 }
7225 HANDLE_EXCEPTION();
7226 }
7227
7228 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
7229 init_func_run_time_cache(&func->op_array);
7230 }
7231 } else {
7232 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
7233 efree(error);
7234
7235 HANDLE_EXCEPTION();
7236 }
7237
7238 call = zend_vm_stack_push_call_frame(call_info,
7239 func, opline->extended_value, object_or_called_scope);
7240 call->prev_execute_data = EX(call);
7241 EX(call) = call;
7242
7243 ZEND_VM_NEXT_OPCODE();
7244 }
7245
ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7246 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7247 {
7248 USE_OPLINE
7249 zval *value, *arg;
7250
7251 if (IS_CONST == IS_CONST) {
7252 SAVE_OPLINE();
7253 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7254 uint32_t arg_num;
7255 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7256 if (UNEXPECTED(!arg)) {
7257
7258 HANDLE_EXCEPTION();
7259 }
7260 } else {
7261 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7262 }
7263
7264 value = RT_CONSTANT(opline, opline->op1);
7265 ZVAL_COPY_VALUE(arg, value);
7266 if (IS_CONST == IS_CONST) {
7267 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7268 Z_ADDREF_P(arg);
7269 }
7270 }
7271 ZEND_VM_NEXT_OPCODE();
7272 }
7273
ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7274 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7275 {
7276 USE_OPLINE
7277 zval *value, *arg;
7278 uint32_t arg_num;
7279
7280 if (IS_CONST == IS_CONST) {
7281 SAVE_OPLINE();
7282 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7283 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7284 if (UNEXPECTED(!arg)) {
7285
7286 HANDLE_EXCEPTION();
7287 }
7288 } else {
7289 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7290 arg_num = opline->op2.num;
7291 }
7292
7293 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
7294 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7295 goto send_val_by_ref;
7296 }
7297 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7298 send_val_by_ref:
7299 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
7300 }
7301 value = RT_CONSTANT(opline, opline->op1);
7302 ZVAL_COPY_VALUE(arg, value);
7303 if (IS_CONST == IS_CONST) {
7304 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7305 Z_ADDREF_P(arg);
7306 }
7307 }
7308 ZEND_VM_NEXT_OPCODE();
7309 }
7310
ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7311 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7312 {
7313 zend_class_entry *ce, *scope;
7314 zend_class_constant *c;
7315 zval *value, *zv, *constant_zv;
7316 zend_string *constant_name;
7317 USE_OPLINE
7318
7319 SAVE_OPLINE();
7320
7321 do {
7322 if (IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
7323 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
7324 value = CACHED_PTR(opline->extended_value + sizeof(void*));
7325 break;
7326 }
7327 }
7328 if (IS_CONST == IS_CONST) {
7329 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
7330 ce = CACHED_PTR(opline->extended_value);
7331 } else {
7332 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);
7333 if (UNEXPECTED(ce == NULL)) {
7334 ZVAL_UNDEF(EX_VAR(opline->result.var));
7335
7336 HANDLE_EXCEPTION();
7337 }
7338 CACHE_PTR(opline->extended_value, ce);
7339 }
7340 } else if (IS_CONST == IS_UNUSED) {
7341 ce = zend_fetch_class(NULL, opline->op1.num);
7342 if (UNEXPECTED(ce == NULL)) {
7343 ZVAL_UNDEF(EX_VAR(opline->result.var));
7344
7345 HANDLE_EXCEPTION();
7346 }
7347 } else {
7348 ce = Z_CE_P(EX_VAR(opline->op1.var));
7349 }
7350 if (IS_CONST != IS_CONST
7351 && IS_CONST == IS_CONST
7352 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
7353 value = CACHED_PTR(opline->extended_value + sizeof(void*));
7354 break;
7355 }
7356
7357 constant_zv = RT_CONSTANT(opline, opline->op2);
7358 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
7359 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
7360 ZVAL_UNDEF(EX_VAR(opline->result.var));
7361
7362 HANDLE_EXCEPTION();
7363 }
7364 constant_name = Z_STR_P(constant_zv);
7365 /* Magic 'class' for constant OP2 is caught at compile-time */
7366 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
7367 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
7368
7369 ZEND_VM_NEXT_OPCODE();
7370 }
7371 zv = IS_CONST == IS_CONST
7372 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
7373 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
7374
7375 if (EXPECTED(zv != NULL)) {
7376 c = Z_PTR_P(zv);
7377 scope = EX(func)->op_array.scope;
7378 if (!zend_verify_const_access(c, scope)) {
7379 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));
7380 ZVAL_UNDEF(EX_VAR(opline->result.var));
7381
7382 HANDLE_EXCEPTION();
7383 }
7384
7385 if (ce->ce_flags & ZEND_ACC_TRAIT) {
7386 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7387 ZVAL_UNDEF(EX_VAR(opline->result.var));
7388
7389 HANDLE_EXCEPTION();
7390 }
7391
7392 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
7393 if (UNEXPECTED(is_constant_deprecated)) {
7394 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7395
7396 if (EG(exception)) {
7397 ZVAL_UNDEF(EX_VAR(opline->result.var));
7398
7399 HANDLE_EXCEPTION();
7400 }
7401 }
7402
7403 value = &c->value;
7404 // Enums require loading of all class constants to build the backed enum table
7405 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)) {
7406 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
7407 ZVAL_UNDEF(EX_VAR(opline->result.var));
7408
7409 HANDLE_EXCEPTION();
7410 }
7411 }
7412 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
7413 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
7414 ZVAL_UNDEF(EX_VAR(opline->result.var));
7415
7416 HANDLE_EXCEPTION();
7417 }
7418 }
7419 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
7420 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
7421 }
7422 } else {
7423 zend_throw_error(NULL, "Undefined constant %s::%s",
7424 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7425 ZVAL_UNDEF(EX_VAR(opline->result.var));
7426
7427 HANDLE_EXCEPTION();
7428 }
7429 } while (0);
7430
7431 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
7432
7433 ZEND_VM_NEXT_OPCODE();
7434 }
7435
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7436 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7437 {
7438 USE_OPLINE
7439 zval *expr_ptr, new_expr;
7440
7441 SAVE_OPLINE();
7442 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
7443 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
7444 expr_ptr = zend_get_bad_ptr();
7445 if (Z_ISREF_P(expr_ptr)) {
7446 Z_ADDREF_P(expr_ptr);
7447 } else {
7448 ZVAL_MAKE_REF_EX(expr_ptr, 2);
7449 }
7450
7451 } else {
7452 expr_ptr = RT_CONSTANT(opline, opline->op1);
7453 if (IS_CONST == IS_TMP_VAR) {
7454 /* pass */
7455 } else if (IS_CONST == IS_CONST) {
7456 Z_TRY_ADDREF_P(expr_ptr);
7457 } else if (IS_CONST == IS_CV) {
7458 ZVAL_DEREF(expr_ptr);
7459 Z_TRY_ADDREF_P(expr_ptr);
7460 } else /* if (IS_CONST == IS_VAR) */ {
7461 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
7462 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
7463
7464 expr_ptr = Z_REFVAL_P(expr_ptr);
7465 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
7466 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
7467 expr_ptr = &new_expr;
7468 efree_size(ref, sizeof(zend_reference));
7469 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
7470 Z_ADDREF_P(expr_ptr);
7471 }
7472 }
7473 }
7474 }
7475
7476 if (IS_CONST != IS_UNUSED) {
7477 zval *offset = RT_CONSTANT(opline, opline->op2);
7478 zend_string *str;
7479 zend_ulong hval;
7480
7481 add_again:
7482 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7483 str = Z_STR_P(offset);
7484 if (IS_CONST != IS_CONST) {
7485 if (ZEND_HANDLE_NUMERIC(str, hval)) {
7486 goto num_index;
7487 }
7488 }
7489 str_index:
7490 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
7491 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7492 hval = Z_LVAL_P(offset);
7493 num_index:
7494 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
7495 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
7496 offset = Z_REFVAL_P(offset);
7497 goto add_again;
7498 } else if (Z_TYPE_P(offset) == IS_NULL) {
7499 str = ZSTR_EMPTY_ALLOC();
7500 goto str_index;
7501 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
7502 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
7503 goto num_index;
7504 } else if (Z_TYPE_P(offset) == IS_FALSE) {
7505 hval = 0;
7506 goto num_index;
7507 } else if (Z_TYPE_P(offset) == IS_TRUE) {
7508 hval = 1;
7509 goto num_index;
7510 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
7511 zend_use_resource_as_offset(offset);
7512 hval = Z_RES_HANDLE_P(offset);
7513 goto num_index;
7514 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
7515 ZVAL_UNDEFINED_OP2();
7516 str = ZSTR_EMPTY_ALLOC();
7517 goto str_index;
7518 } else {
7519 zend_illegal_array_offset_access(offset);
7520 zval_ptr_dtor_nogc(expr_ptr);
7521 }
7522
7523 } else {
7524 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
7525 zend_cannot_add_element();
7526 zval_ptr_dtor_nogc(expr_ptr);
7527 }
7528 }
7529 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7530 }
7531
ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7532 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7533 {
7534 zval *array;
7535 uint32_t size;
7536 USE_OPLINE
7537
7538 array = EX_VAR(opline->result.var);
7539 if (IS_CONST != IS_UNUSED) {
7540 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
7541 ZVAL_ARR(array, zend_new_array(size));
7542 /* Explicitly initialize array as not-packed if flag is set */
7543 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
7544 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
7545 }
7546 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7547 } else {
7548 ZVAL_ARR(array, zend_new_array(0));
7549 ZEND_VM_NEXT_OPCODE();
7550 }
7551 }
7552
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7553 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7554 {
7555 USE_OPLINE
7556 zval *container;
7557 bool result;
7558 zend_ulong hval;
7559 zval *offset;
7560
7561 SAVE_OPLINE();
7562 container = RT_CONSTANT(opline, opline->op1);
7563 offset = RT_CONSTANT(opline, opline->op2);
7564
7565 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7566 HashTable *ht;
7567 zval *value;
7568 zend_string *str;
7569
7570 isset_dim_obj_array:
7571 ht = Z_ARRVAL_P(container);
7572 isset_again:
7573 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7574 str = Z_STR_P(offset);
7575 if (IS_CONST != IS_CONST) {
7576 if (ZEND_HANDLE_NUMERIC(str, hval)) {
7577 goto num_index_prop;
7578 }
7579 }
7580 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
7581 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7582 hval = Z_LVAL_P(offset);
7583 num_index_prop:
7584 value = zend_hash_index_find(ht, hval);
7585 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
7586 offset = Z_REFVAL_P(offset);
7587 goto isset_again;
7588 } else {
7589 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
7590 if (UNEXPECTED(EG(exception))) {
7591 result = 0;
7592 goto isset_dim_obj_exit;
7593 }
7594 }
7595
7596 if (!(opline->extended_value & ZEND_ISEMPTY)) {
7597 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
7598 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
7599 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
7600
7601 if (IS_CONST & (IS_CONST|IS_CV)) {
7602 /* avoid exception check */
7603
7604 ZEND_VM_SMART_BRANCH(result, 0);
7605 }
7606 } else {
7607 result = (value == NULL || !i_zend_is_true(value));
7608 }
7609 goto isset_dim_obj_exit;
7610 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
7611 container = Z_REFVAL_P(container);
7612 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7613 goto isset_dim_obj_array;
7614 }
7615 }
7616
7617 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
7618 offset++;
7619 }
7620 if (!(opline->extended_value & ZEND_ISEMPTY)) {
7621 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
7622 } else {
7623 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
7624 }
7625
7626 isset_dim_obj_exit:
7627
7628
7629 ZEND_VM_SMART_BRANCH(result, 1);
7630 }
7631
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7632 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7633 {
7634 USE_OPLINE
7635 zval *container;
7636 int result;
7637 zval *offset;
7638 zend_string *name, *tmp_name;
7639
7640 SAVE_OPLINE();
7641 container = RT_CONSTANT(opline, opline->op1);
7642 offset = RT_CONSTANT(opline, opline->op2);
7643
7644 if (IS_CONST == IS_CONST ||
7645 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
7646 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
7647 container = Z_REFVAL_P(container);
7648 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
7649 result = (opline->extended_value & ZEND_ISEMPTY);
7650 goto isset_object_finish;
7651 }
7652 } else {
7653 result = (opline->extended_value & ZEND_ISEMPTY);
7654 goto isset_object_finish;
7655 }
7656 }
7657
7658 if (IS_CONST == IS_CONST) {
7659 name = Z_STR_P(offset);
7660 } else {
7661 name = zval_try_get_tmp_string(offset, &tmp_name);
7662 if (UNEXPECTED(!name)) {
7663 result = 0;
7664 goto isset_object_finish;
7665 }
7666 }
7667
7668 result =
7669 (opline->extended_value & ZEND_ISEMPTY) ^
7670 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));
7671
7672 if (IS_CONST != IS_CONST) {
7673 zend_tmp_string_release(tmp_name);
7674 }
7675
7676 isset_object_finish:
7677
7678
7679 ZEND_VM_SMART_BRANCH(result, 1);
7680 }
7681
ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7682 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7683 {
7684 USE_OPLINE
7685
7686 zval *key, *subject;
7687 HashTable *ht;
7688 bool result;
7689
7690 SAVE_OPLINE();
7691
7692 key = RT_CONSTANT(opline, opline->op1);
7693 subject = RT_CONSTANT(opline, opline->op2);
7694
7695 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7696 array_key_exists_array:
7697 ht = Z_ARRVAL_P(subject);
7698 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
7699 } else {
7700 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
7701 subject = Z_REFVAL_P(subject);
7702 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7703 goto array_key_exists_array;
7704 }
7705 }
7706 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
7707 result = 0;
7708 }
7709
7710
7711 ZEND_VM_SMART_BRANCH(result, 1);
7712 }
7713
7714 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7715 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7716 {
7717 USE_OPLINE
7718
7719 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
7720 if (ce == NULL) {
7721 zval *lcname = RT_CONSTANT(opline, opline->op1);
7722 zval *zv = zend_hash_find_known_hash(EG(class_table), Z_STR_P(lcname + 1));
7723 if (zv) {
7724 SAVE_OPLINE();
7725 ce = zend_bind_class_in_slot(zv, lcname, Z_STR_P(RT_CONSTANT(opline, opline->op2)));
7726 if (!ce) {
7727 HANDLE_EXCEPTION();
7728 }
7729 }
7730 CACHE_PTR(opline->extended_value, ce);
7731 }
7732 ZEND_VM_NEXT_OPCODE();
7733 }
7734
ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7735 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7736 {
7737 USE_OPLINE
7738 zval *name;
7739 zval *val;
7740 zend_constant c;
7741
7742 SAVE_OPLINE();
7743 name = RT_CONSTANT(opline, opline->op1);
7744 val = RT_CONSTANT(opline, opline->op2);
7745
7746 ZVAL_COPY(&c.value, val);
7747 if (Z_OPT_CONSTANT(c.value)) {
7748 if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) {
7749 zval_ptr_dtor_nogc(&c.value);
7750
7751
7752 HANDLE_EXCEPTION();
7753 }
7754 }
7755 /* non persistent, case sensitive */
7756 ZEND_CONSTANT_SET_FLAGS(&c, 0, PHP_USER_CONSTANT);
7757 c.name = zend_string_copy(Z_STR_P(name));
7758
7759 if (zend_register_constant(&c) == FAILURE) {
7760 }
7761
7762
7763 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7764 }
7765
ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7766 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7767 {
7768 USE_OPLINE
7769
7770 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
7771
7772 SAVE_OPLINE();
7773 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
7774 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7775 }
7776
7777 /* Destroy the previously yielded value */
7778 zval_ptr_dtor(&generator->value);
7779
7780 /* Destroy the previously yielded key */
7781 zval_ptr_dtor(&generator->key);
7782
7783 /* Set the new yielded value */
7784 if (IS_CONST != IS_UNUSED) {
7785 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
7786 /* Constants and temporary variables aren't yieldable by reference,
7787 * but we still allow them with a notice. */
7788 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
7789 zval *value;
7790
7791 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
7792
7793 value = RT_CONSTANT(opline, opline->op1);
7794 ZVAL_COPY_VALUE(&generator->value, value);
7795 if (IS_CONST == IS_CONST) {
7796 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
7797 Z_ADDREF(generator->value);
7798 }
7799 }
7800 } else {
7801 zval *value_ptr = zend_get_bad_ptr();
7802
7803 /* If a function call result is yielded and the function did
7804 * not return by reference we throw a notice. */
7805 do {
7806 if (IS_CONST == IS_VAR) {
7807 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
7808 if (opline->extended_value == ZEND_RETURNS_FUNCTION
7809 && !Z_ISREF_P(value_ptr)) {
7810 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
7811 ZVAL_COPY(&generator->value, value_ptr);
7812 break;
7813 }
7814 }
7815 if (Z_ISREF_P(value_ptr)) {
7816 Z_ADDREF_P(value_ptr);
7817 } else {
7818 ZVAL_MAKE_REF_EX(value_ptr, 2);
7819 }
7820 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
7821 } while (0);
7822
7823 }
7824 } else {
7825 zval *value = RT_CONSTANT(opline, opline->op1);
7826
7827 /* Consts, temporary variables and references need copying */
7828 if (IS_CONST == IS_CONST) {
7829 ZVAL_COPY_VALUE(&generator->value, value);
7830 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
7831 Z_ADDREF(generator->value);
7832 }
7833 } else if (IS_CONST == IS_TMP_VAR) {
7834 ZVAL_COPY_VALUE(&generator->value, value);
7835 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
7836 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
7837
7838 } else {
7839 ZVAL_COPY_VALUE(&generator->value, value);
7840 if (IS_CONST == IS_CV) {
7841 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
7842 }
7843 }
7844 }
7845 } else {
7846 /* If no value was specified yield null */
7847 ZVAL_NULL(&generator->value);
7848 }
7849
7850 /* Set the new yielded key */
7851 if (IS_CONST != IS_UNUSED) {
7852 zval *key = RT_CONSTANT(opline, opline->op2);
7853 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
7854 key = Z_REFVAL_P(key);
7855 }
7856 ZVAL_COPY(&generator->key, key);
7857
7858 if (Z_TYPE(generator->key) == IS_LONG
7859 && Z_LVAL(generator->key) > generator->largest_used_integer_key
7860 ) {
7861 generator->largest_used_integer_key = Z_LVAL(generator->key);
7862 }
7863 } else {
7864 /* If no key was specified we use auto-increment keys */
7865 generator->largest_used_integer_key++;
7866 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
7867 }
7868
7869 if (RETURN_VALUE_USED(opline)) {
7870 /* If the return value of yield is used set the send
7871 * target and initialize it to NULL */
7872 generator->send_target = EX_VAR(opline->result.var);
7873 ZVAL_NULL(generator->send_target);
7874 } else {
7875 generator->send_target = NULL;
7876 }
7877
7878 /* We increment to the next op, so we are at the correct position when the
7879 * generator is resumed. */
7880 ZEND_VM_INC_OPCODE();
7881
7882 /* The GOTO VM uses a local opline variable. We need to set the opline
7883 * variable in execute_data so we don't resume at an old position. */
7884 SAVE_OPLINE();
7885
7886 ZEND_VM_RETURN();
7887 }
7888
ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7889 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7890 {
7891 USE_OPLINE
7892 zval *op, *jump_zv;
7893 HashTable *jumptable;
7894
7895 op = RT_CONSTANT(opline, opline->op1);
7896
7897 if (Z_TYPE_P(op) != IS_LONG) {
7898 ZVAL_DEREF(op);
7899 if (Z_TYPE_P(op) != IS_LONG) {
7900 /* Wrong type, fall back to ZEND_CASE chain */
7901 ZEND_VM_NEXT_OPCODE();
7902 }
7903 }
7904
7905 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
7906 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
7907 if (jump_zv != NULL) {
7908 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
7909 ZEND_VM_CONTINUE();
7910 } else {
7911 /* default */
7912 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
7913 ZEND_VM_CONTINUE();
7914 }
7915 }
7916
ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7917 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7918 {
7919 USE_OPLINE
7920 zval *op, *jump_zv;
7921 HashTable *jumptable;
7922
7923 op = RT_CONSTANT(opline, opline->op1);
7924
7925 if (Z_TYPE_P(op) != IS_STRING) {
7926 if (IS_CONST == IS_CONST) {
7927 /* Wrong type, fall back to ZEND_CASE chain */
7928 ZEND_VM_NEXT_OPCODE();
7929 } else {
7930 ZVAL_DEREF(op);
7931 if (Z_TYPE_P(op) != IS_STRING) {
7932 /* Wrong type, fall back to ZEND_CASE chain */
7933 ZEND_VM_NEXT_OPCODE();
7934 }
7935 }
7936 }
7937
7938 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
7939 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
7940 if (jump_zv != NULL) {
7941 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
7942 ZEND_VM_CONTINUE();
7943 } else {
7944 /* default */
7945 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
7946 ZEND_VM_CONTINUE();
7947 }
7948 }
7949
ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7950 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7951 {
7952 USE_OPLINE
7953 zval *op, *jump_zv;
7954 HashTable *jumptable;
7955
7956 op = RT_CONSTANT(opline, opline->op1);
7957 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
7958
7959 match_try_again:
7960 if (Z_TYPE_P(op) == IS_LONG) {
7961 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
7962 } else if (Z_TYPE_P(op) == IS_STRING) {
7963 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
7964 } else if (Z_TYPE_P(op) == IS_REFERENCE) {
7965 op = Z_REFVAL_P(op);
7966 goto match_try_again;
7967 } else {
7968 if (UNEXPECTED((IS_CONST & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
7969 SAVE_OPLINE();
7970 op = ZVAL_UNDEFINED_OP1();
7971 if (UNEXPECTED(EG(exception))) {
7972 HANDLE_EXCEPTION();
7973 }
7974 goto match_try_again;
7975 }
7976
7977 goto default_branch;
7978 }
7979
7980 if (jump_zv != NULL) {
7981 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
7982 ZEND_VM_CONTINUE();
7983 } else {
7984 default_branch:
7985 /* default */
7986 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
7987 ZEND_VM_CONTINUE();
7988 }
7989 }
7990
ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7991 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7992 {
7993 USE_OPLINE
7994 zval *op1;
7995 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
7996 zval *result;
7997
7998 op1 = RT_CONSTANT(opline, opline->op1);
7999 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8000 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CONST == IS_CONST);
8001 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8002 zval_ptr_dtor_str(op1);
8003 }
8004 ZEND_VM_SMART_BRANCH(result, 0);
8005 }
8006
8007 if (opline->extended_value) {
8008 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8009 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8010 ZEND_VM_SMART_BRANCH(result, 0);
8011 }
8012 SAVE_OPLINE();
8013 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8014 op1 = Z_REFVAL_P(op1);
8015 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8016 result = zend_hash_find(ht, Z_STR_P(op1));
8017
8018 ZEND_VM_SMART_BRANCH(result, 0);
8019 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8020 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8021
8022 ZEND_VM_SMART_BRANCH(result, 0);
8023 }
8024 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8025 ZVAL_UNDEFINED_OP1();
8026 }
8027 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
8028 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8029 SAVE_OPLINE();
8030 ZVAL_UNDEFINED_OP1();
8031 if (UNEXPECTED(EG(exception) != NULL)) {
8032 HANDLE_EXCEPTION();
8033 }
8034 }
8035 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
8036 ZEND_VM_SMART_BRANCH(result, 0);
8037 } else {
8038 zend_string *key;
8039 zval key_tmp;
8040
8041 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8042 op1 = Z_REFVAL_P(op1);
8043 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8044 result = zend_hash_find(ht, Z_STR_P(op1));
8045
8046 ZEND_VM_SMART_BRANCH(result, 0);
8047 }
8048 }
8049
8050 SAVE_OPLINE();
8051 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
8052 ZVAL_STR(&key_tmp, key);
8053 if (zend_compare(op1, &key_tmp) == 0) {
8054
8055 ZEND_VM_SMART_BRANCH(1, 1);
8056 }
8057 } ZEND_HASH_FOREACH_END();
8058 }
8059
8060 ZEND_VM_SMART_BRANCH(0, 1);
8061 }
8062
ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8063 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8064 {
8065 USE_OPLINE
8066 zval *op1, *op2, *result;
8067 double d1, d2;
8068
8069 op1 = RT_CONSTANT(opline, opline->op1);
8070 op2 = EX_VAR(opline->op2.var);
8071 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8072 /* pass */
8073 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8074 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8075 result = EX_VAR(opline->result.var);
8076 fast_long_add_function(result, op1, op2);
8077 ZEND_VM_NEXT_OPCODE();
8078 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8079 d1 = (double)Z_LVAL_P(op1);
8080 d2 = Z_DVAL_P(op2);
8081 goto add_double;
8082 }
8083 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8084 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8085 d1 = Z_DVAL_P(op1);
8086 d2 = Z_DVAL_P(op2);
8087 add_double:
8088 result = EX_VAR(opline->result.var);
8089 ZVAL_DOUBLE(result, d1 + d2);
8090 ZEND_VM_NEXT_OPCODE();
8091 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8092 d1 = Z_DVAL_P(op1);
8093 d2 = (double)Z_LVAL_P(op2);
8094 goto add_double;
8095 }
8096 }
8097
8098 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8099 }
8100
ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8101 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8102 {
8103 USE_OPLINE
8104 zval *op1, *op2, *result;
8105 double d1, d2;
8106
8107 op1 = RT_CONSTANT(opline, opline->op1);
8108 op2 = EX_VAR(opline->op2.var);
8109 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8110 /* pass */
8111 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8112 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8113 result = EX_VAR(opline->result.var);
8114 fast_long_sub_function(result, op1, op2);
8115 ZEND_VM_NEXT_OPCODE();
8116 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8117 d1 = (double)Z_LVAL_P(op1);
8118 d2 = Z_DVAL_P(op2);
8119 goto sub_double;
8120 }
8121 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8122 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8123 d1 = Z_DVAL_P(op1);
8124 d2 = Z_DVAL_P(op2);
8125 sub_double:
8126 result = EX_VAR(opline->result.var);
8127 ZVAL_DOUBLE(result, d1 - d2);
8128 ZEND_VM_NEXT_OPCODE();
8129 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8130 d1 = Z_DVAL_P(op1);
8131 d2 = (double)Z_LVAL_P(op2);
8132 goto sub_double;
8133 }
8134 }
8135
8136 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8137 }
8138
ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8139 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8140 {
8141 USE_OPLINE
8142 zval *op1, *op2, *result;
8143
8144 op1 = RT_CONSTANT(opline, opline->op1);
8145 op2 = EX_VAR(opline->op2.var);
8146 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8147 /* pass */
8148 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8149 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8150 result = EX_VAR(opline->result.var);
8151 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
8152 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8153 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
8154 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
8155 ZVAL_LONG(result, 0);
8156 } else {
8157 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
8158 }
8159 ZEND_VM_NEXT_OPCODE();
8160 }
8161 }
8162
8163 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8164 }
8165
ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8166 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8167 {
8168 USE_OPLINE
8169 zval *op1, *op2;
8170
8171 op1 = RT_CONSTANT(opline, opline->op1);
8172 op2 = EX_VAR(opline->op2.var);
8173 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8174 /* pass */
8175 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8176 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8177 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8178 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
8179 ZVAL_LONG(EX_VAR(opline->result.var),
8180 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
8181 ZEND_VM_NEXT_OPCODE();
8182 }
8183
8184 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8185 }
8186
ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8187 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8188 {
8189 USE_OPLINE
8190 zval *op1, *op2;
8191
8192 op1 = RT_CONSTANT(opline, opline->op1);
8193 op2 = EX_VAR(opline->op2.var);
8194 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8195 /* pass */
8196 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8197 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8198 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8199 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
8200 ZEND_VM_NEXT_OPCODE();
8201 }
8202
8203 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8204 }
8205
ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8206 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8207 {
8208 USE_OPLINE
8209 zval *op1, *op2;
8210 double d1, d2;
8211
8212 op1 = RT_CONSTANT(opline, opline->op1);
8213 op2 = EX_VAR(opline->op2.var);
8214 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8215 /* pass */
8216 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8217 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8218 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8219 is_smaller_true:
8220 ZEND_VM_SMART_BRANCH_TRUE_NONE();
8221 } else {
8222 is_smaller_false:
8223 ZEND_VM_SMART_BRANCH_FALSE_NONE();
8224 }
8225 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8226 d1 = (double)Z_LVAL_P(op1);
8227 d2 = Z_DVAL_P(op2);
8228 goto is_smaller_double;
8229 }
8230 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8231 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8232 d1 = Z_DVAL_P(op1);
8233 d2 = Z_DVAL_P(op2);
8234 is_smaller_double:
8235 if (d1 < d2) {
8236 goto is_smaller_true;
8237 } else {
8238 goto is_smaller_false;
8239 }
8240 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8241 d1 = Z_DVAL_P(op1);
8242 d2 = (double)Z_LVAL_P(op2);
8243 goto is_smaller_double;
8244 }
8245 }
8246 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8247 }
8248
ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8249 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8250 {
8251 USE_OPLINE
8252 zval *op1, *op2;
8253 double d1, d2;
8254
8255 op1 = RT_CONSTANT(opline, opline->op1);
8256 op2 = EX_VAR(opline->op2.var);
8257 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8258 /* pass */
8259 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8260 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8261 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8262 is_smaller_true:
8263 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8264 } else {
8265 is_smaller_false:
8266 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8267 }
8268 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8269 d1 = (double)Z_LVAL_P(op1);
8270 d2 = Z_DVAL_P(op2);
8271 goto is_smaller_double;
8272 }
8273 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8274 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8275 d1 = Z_DVAL_P(op1);
8276 d2 = Z_DVAL_P(op2);
8277 is_smaller_double:
8278 if (d1 < d2) {
8279 goto is_smaller_true;
8280 } else {
8281 goto is_smaller_false;
8282 }
8283 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8284 d1 = Z_DVAL_P(op1);
8285 d2 = (double)Z_LVAL_P(op2);
8286 goto is_smaller_double;
8287 }
8288 }
8289 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8290 }
8291
ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8292 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8293 {
8294 USE_OPLINE
8295 zval *op1, *op2;
8296 double d1, d2;
8297
8298 op1 = RT_CONSTANT(opline, opline->op1);
8299 op2 = EX_VAR(opline->op2.var);
8300 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8301 /* pass */
8302 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8303 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8304 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8305 is_smaller_true:
8306 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8307 } else {
8308 is_smaller_false:
8309 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8310 }
8311 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8312 d1 = (double)Z_LVAL_P(op1);
8313 d2 = Z_DVAL_P(op2);
8314 goto is_smaller_double;
8315 }
8316 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8317 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8318 d1 = Z_DVAL_P(op1);
8319 d2 = Z_DVAL_P(op2);
8320 is_smaller_double:
8321 if (d1 < d2) {
8322 goto is_smaller_true;
8323 } else {
8324 goto is_smaller_false;
8325 }
8326 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8327 d1 = Z_DVAL_P(op1);
8328 d2 = (double)Z_LVAL_P(op2);
8329 goto is_smaller_double;
8330 }
8331 }
8332 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8333 }
8334
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8335 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8336 {
8337 USE_OPLINE
8338 zval *op1, *op2;
8339 double d1, d2;
8340
8341 op1 = RT_CONSTANT(opline, opline->op1);
8342 op2 = EX_VAR(opline->op2.var);
8343 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8344 /* pass */
8345 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8346 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8347 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8348 is_smaller_or_equal_true:
8349 ZEND_VM_SMART_BRANCH_TRUE_NONE();
8350 ZVAL_TRUE(EX_VAR(opline->result.var));
8351 ZEND_VM_NEXT_OPCODE();
8352 } else {
8353 is_smaller_or_equal_false:
8354 ZEND_VM_SMART_BRANCH_FALSE_NONE();
8355 ZVAL_FALSE(EX_VAR(opline->result.var));
8356 ZEND_VM_NEXT_OPCODE();
8357 }
8358 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8359 d1 = (double)Z_LVAL_P(op1);
8360 d2 = Z_DVAL_P(op2);
8361 goto is_smaller_or_equal_double;
8362 }
8363 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8364 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8365 d1 = Z_DVAL_P(op1);
8366 d2 = Z_DVAL_P(op2);
8367 is_smaller_or_equal_double:
8368 if (d1 <= d2) {
8369 goto is_smaller_or_equal_true;
8370 } else {
8371 goto is_smaller_or_equal_false;
8372 }
8373 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8374 d1 = Z_DVAL_P(op1);
8375 d2 = (double)Z_LVAL_P(op2);
8376 goto is_smaller_or_equal_double;
8377 }
8378 }
8379 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8380 }
8381
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8382 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8383 {
8384 USE_OPLINE
8385 zval *op1, *op2;
8386 double d1, d2;
8387
8388 op1 = RT_CONSTANT(opline, opline->op1);
8389 op2 = EX_VAR(opline->op2.var);
8390 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8391 /* pass */
8392 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8393 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8394 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8395 is_smaller_or_equal_true:
8396 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8397 ZVAL_TRUE(EX_VAR(opline->result.var));
8398 ZEND_VM_NEXT_OPCODE();
8399 } else {
8400 is_smaller_or_equal_false:
8401 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8402 ZVAL_FALSE(EX_VAR(opline->result.var));
8403 ZEND_VM_NEXT_OPCODE();
8404 }
8405 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8406 d1 = (double)Z_LVAL_P(op1);
8407 d2 = Z_DVAL_P(op2);
8408 goto is_smaller_or_equal_double;
8409 }
8410 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8411 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8412 d1 = Z_DVAL_P(op1);
8413 d2 = Z_DVAL_P(op2);
8414 is_smaller_or_equal_double:
8415 if (d1 <= d2) {
8416 goto is_smaller_or_equal_true;
8417 } else {
8418 goto is_smaller_or_equal_false;
8419 }
8420 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8421 d1 = Z_DVAL_P(op1);
8422 d2 = (double)Z_LVAL_P(op2);
8423 goto is_smaller_or_equal_double;
8424 }
8425 }
8426 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8427 }
8428
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8429 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8430 {
8431 USE_OPLINE
8432 zval *op1, *op2;
8433 double d1, d2;
8434
8435 op1 = RT_CONSTANT(opline, opline->op1);
8436 op2 = EX_VAR(opline->op2.var);
8437 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8438 /* pass */
8439 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8440 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8441 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8442 is_smaller_or_equal_true:
8443 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8444 ZVAL_TRUE(EX_VAR(opline->result.var));
8445 ZEND_VM_NEXT_OPCODE();
8446 } else {
8447 is_smaller_or_equal_false:
8448 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8449 ZVAL_FALSE(EX_VAR(opline->result.var));
8450 ZEND_VM_NEXT_OPCODE();
8451 }
8452 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8453 d1 = (double)Z_LVAL_P(op1);
8454 d2 = Z_DVAL_P(op2);
8455 goto is_smaller_or_equal_double;
8456 }
8457 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8458 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8459 d1 = Z_DVAL_P(op1);
8460 d2 = Z_DVAL_P(op2);
8461 is_smaller_or_equal_double:
8462 if (d1 <= d2) {
8463 goto is_smaller_or_equal_true;
8464 } else {
8465 goto is_smaller_or_equal_false;
8466 }
8467 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8468 d1 = Z_DVAL_P(op1);
8469 d2 = (double)Z_LVAL_P(op2);
8470 goto is_smaller_or_equal_double;
8471 }
8472 }
8473 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8474 }
8475
ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8476 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8477 {
8478 zend_class_entry *ce, *scope;
8479 zend_class_constant *c;
8480 zval *value, *zv, *constant_zv;
8481 zend_string *constant_name;
8482 USE_OPLINE
8483
8484 SAVE_OPLINE();
8485
8486 do {
8487 if (IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8488 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
8489 value = CACHED_PTR(opline->extended_value + sizeof(void*));
8490 break;
8491 }
8492 }
8493 if (IS_CONST == IS_CONST) {
8494 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
8495 ce = CACHED_PTR(opline->extended_value);
8496 } else {
8497 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);
8498 if (UNEXPECTED(ce == NULL)) {
8499 ZVAL_UNDEF(EX_VAR(opline->result.var));
8500 FREE_OP(opline->op2_type, opline->op2.var);
8501 HANDLE_EXCEPTION();
8502 }
8503 CACHE_PTR(opline->extended_value, ce);
8504 }
8505 } else if (IS_CONST == IS_UNUSED) {
8506 ce = zend_fetch_class(NULL, opline->op1.num);
8507 if (UNEXPECTED(ce == NULL)) {
8508 ZVAL_UNDEF(EX_VAR(opline->result.var));
8509 FREE_OP(opline->op2_type, opline->op2.var);
8510 HANDLE_EXCEPTION();
8511 }
8512 } else {
8513 ce = Z_CE_P(EX_VAR(opline->op1.var));
8514 }
8515 if (IS_CONST != IS_CONST
8516 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8517 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
8518 value = CACHED_PTR(opline->extended_value + sizeof(void*));
8519 break;
8520 }
8521
8522 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
8523 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
8524 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
8525 ZVAL_UNDEF(EX_VAR(opline->result.var));
8526 FREE_OP(opline->op2_type, opline->op2.var);
8527 HANDLE_EXCEPTION();
8528 }
8529 constant_name = Z_STR_P(constant_zv);
8530 /* Magic 'class' for constant OP2 is caught at compile-time */
8531 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
8532 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
8533 FREE_OP(opline->op2_type, opline->op2.var);
8534 ZEND_VM_NEXT_OPCODE();
8535 }
8536 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8537 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
8538 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
8539
8540 if (EXPECTED(zv != NULL)) {
8541 c = Z_PTR_P(zv);
8542 scope = EX(func)->op_array.scope;
8543 if (!zend_verify_const_access(c, scope)) {
8544 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));
8545 ZVAL_UNDEF(EX_VAR(opline->result.var));
8546 FREE_OP(opline->op2_type, opline->op2.var);
8547 HANDLE_EXCEPTION();
8548 }
8549
8550 if (ce->ce_flags & ZEND_ACC_TRAIT) {
8551 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8552 ZVAL_UNDEF(EX_VAR(opline->result.var));
8553 FREE_OP(opline->op2_type, opline->op2.var);
8554 HANDLE_EXCEPTION();
8555 }
8556
8557 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
8558 if (UNEXPECTED(is_constant_deprecated)) {
8559 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8560
8561 if (EG(exception)) {
8562 ZVAL_UNDEF(EX_VAR(opline->result.var));
8563 FREE_OP(opline->op2_type, opline->op2.var);
8564 HANDLE_EXCEPTION();
8565 }
8566 }
8567
8568 value = &c->value;
8569 // Enums require loading of all class constants to build the backed enum table
8570 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)) {
8571 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
8572 ZVAL_UNDEF(EX_VAR(opline->result.var));
8573 FREE_OP(opline->op2_type, opline->op2.var);
8574 HANDLE_EXCEPTION();
8575 }
8576 }
8577 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
8578 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
8579 ZVAL_UNDEF(EX_VAR(opline->result.var));
8580 FREE_OP(opline->op2_type, opline->op2.var);
8581 HANDLE_EXCEPTION();
8582 }
8583 }
8584 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
8585 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
8586 }
8587 } else {
8588 zend_throw_error(NULL, "Undefined constant %s::%s",
8589 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8590 ZVAL_UNDEF(EX_VAR(opline->result.var));
8591 FREE_OP(opline->op2_type, opline->op2.var);
8592 HANDLE_EXCEPTION();
8593 }
8594 } while (0);
8595
8596 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
8597
8598 FREE_OP(opline->op2_type, opline->op2.var);
8599 ZEND_VM_NEXT_OPCODE();
8600 }
8601
ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8602 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8603 {
8604 USE_OPLINE
8605 zval *op1, *op2, *result;
8606
8607 op1 = RT_CONSTANT(opline, opline->op1);
8608 op2 = EX_VAR(opline->op2.var);
8609 result = EX_VAR(opline->result.var);
8610 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
8611 ZEND_VM_NEXT_OPCODE();
8612 }
8613
ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8614 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8615 {
8616 USE_OPLINE
8617 zval *op1, *op2, *result;
8618
8619 op1 = RT_CONSTANT(opline, opline->op1);
8620 op2 = EX_VAR(opline->op2.var);
8621 result = EX_VAR(opline->result.var);
8622 fast_long_sub_function(result, op1, op2);
8623 ZEND_VM_NEXT_OPCODE();
8624 }
8625
ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8626 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8627 {
8628 USE_OPLINE
8629 zval *op1, *op2, *result;
8630
8631 op1 = RT_CONSTANT(opline, opline->op1);
8632 op2 = EX_VAR(opline->op2.var);
8633 result = EX_VAR(opline->result.var);
8634 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
8635 ZEND_VM_NEXT_OPCODE();
8636 }
8637
ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8638 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8639 {
8640 USE_OPLINE
8641 zval *op1, *op2;
8642 bool result;
8643
8644 op1 = RT_CONSTANT(opline, opline->op1);
8645 op2 = EX_VAR(opline->op2.var);
8646 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8647 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8648 }
8649
ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8650 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8651 {
8652 USE_OPLINE
8653 zval *op1, *op2;
8654 bool result;
8655
8656 op1 = RT_CONSTANT(opline, opline->op1);
8657 op2 = EX_VAR(opline->op2.var);
8658 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8659 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8660 }
8661
ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8662 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8663 {
8664 USE_OPLINE
8665 zval *op1, *op2;
8666 bool result;
8667
8668 op1 = RT_CONSTANT(opline, opline->op1);
8669 op2 = EX_VAR(opline->op2.var);
8670 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8671 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8672 }
8673
ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8674 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8675 {
8676 USE_OPLINE
8677 zval *op1, *op2;
8678 bool result;
8679
8680 op1 = RT_CONSTANT(opline, opline->op1);
8681 op2 = EX_VAR(opline->op2.var);
8682 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8683 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8684 }
8685
ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8686 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8687 {
8688 USE_OPLINE
8689 zval *op1, *op2;
8690 bool result;
8691
8692 op1 = RT_CONSTANT(opline, opline->op1);
8693 op2 = EX_VAR(opline->op2.var);
8694 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8695 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8696 }
8697
ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8698 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8699 {
8700 USE_OPLINE
8701 zval *op1, *op2;
8702 bool result;
8703
8704 op1 = RT_CONSTANT(opline, opline->op1);
8705 op2 = EX_VAR(opline->op2.var);
8706 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8707 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8708 }
8709
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8710 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8711 {
8712 USE_OPLINE
8713 zval *op1, *op2;
8714 bool result;
8715
8716 op1 = RT_CONSTANT(opline, opline->op1);
8717 op2 = EX_VAR(opline->op2.var);
8718 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8719 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8720 }
8721
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8722 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)
8723 {
8724 USE_OPLINE
8725 zval *op1, *op2;
8726 bool result;
8727
8728 op1 = RT_CONSTANT(opline, opline->op1);
8729 op2 = EX_VAR(opline->op2.var);
8730 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8731 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8732 }
8733
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8734 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)
8735 {
8736 USE_OPLINE
8737 zval *op1, *op2;
8738 bool result;
8739
8740 op1 = RT_CONSTANT(opline, opline->op1);
8741 op2 = EX_VAR(opline->op2.var);
8742 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8743 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8744 }
8745
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8746 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8747 {
8748 USE_OPLINE
8749 zval *op1, *op2;
8750 bool result;
8751
8752 op1 = RT_CONSTANT(opline, opline->op1);
8753 op2 = EX_VAR(opline->op2.var);
8754 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8755 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8756 }
8757
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8758 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)
8759 {
8760 USE_OPLINE
8761 zval *op1, *op2;
8762 bool result;
8763
8764 op1 = RT_CONSTANT(opline, opline->op1);
8765 op2 = EX_VAR(opline->op2.var);
8766 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8767 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8768 }
8769
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8770 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)
8771 {
8772 USE_OPLINE
8773 zval *op1, *op2;
8774 bool result;
8775
8776 op1 = RT_CONSTANT(opline, opline->op1);
8777 op2 = EX_VAR(opline->op2.var);
8778 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8779 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8780 }
8781
ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8782 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8783 {
8784 USE_OPLINE
8785 zval *container, *dim, *value;
8786 zend_long offset;
8787 HashTable *ht;
8788
8789 container = RT_CONSTANT(opline, opline->op1);
8790 dim = EX_VAR(opline->op2.var);
8791 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
8792 fetch_dim_r_index_array:
8793 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
8794 offset = Z_LVAL_P(dim);
8795 } else {
8796 SAVE_OPLINE();
8797 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
8798
8799 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8800 }
8801 ht = Z_ARRVAL_P(container);
8802 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
8803 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
8804 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8805 SAVE_OPLINE();
8806
8807 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8808 } else {
8809 ZEND_VM_NEXT_OPCODE();
8810 }
8811 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
8812 container = Z_REFVAL_P(container);
8813 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
8814 goto fetch_dim_r_index_array;
8815 } else {
8816 goto fetch_dim_r_index_slow;
8817 }
8818 } else {
8819 fetch_dim_r_index_slow:
8820 SAVE_OPLINE();
8821 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
8822 dim++;
8823 }
8824 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
8825
8826 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8827 }
8828
8829 fetch_dim_r_index_undef:
8830 ZVAL_NULL(EX_VAR(opline->result.var));
8831 SAVE_OPLINE();
8832 zend_undefined_offset(offset);
8833
8834 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8835 }
8836
ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8837 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8838 {
8839 USE_OPLINE
8840 zval *op1, *op2;
8841
8842 SAVE_OPLINE();
8843 op1 = RT_CONSTANT(opline, opline->op1);
8844 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
8845 div_function(EX_VAR(opline->result.var), op1, op2);
8846
8847 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8848 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8849 }
8850
ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8851 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8852 {
8853 USE_OPLINE
8854 zval *op1, *op2;
8855
8856 SAVE_OPLINE();
8857 op1 = RT_CONSTANT(opline, opline->op1);
8858 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
8859 pow_function(EX_VAR(opline->result.var), op1, op2);
8860
8861 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8862 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8863 }
8864
ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8865 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8866 {
8867 USE_OPLINE
8868 zval *op1, *op2;
8869
8870 op1 = RT_CONSTANT(opline, opline->op1);
8871 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
8872
8873 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
8874 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
8875 zend_string *op1_str = Z_STR_P(op1);
8876 zend_string *op2_str = Z_STR_P(op2);
8877 zend_string *str;
8878 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
8879
8880 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
8881 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
8882 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
8883 } else {
8884 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
8885 }
8886 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8887 zend_string_release_ex(op1_str, 0);
8888 }
8889 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
8890 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
8891 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
8892 } else {
8893 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
8894 }
8895 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
8896 zend_string_release_ex(op2_str, 0);
8897 }
8898 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
8899 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
8900 size_t len = ZSTR_LEN(op1_str);
8901
8902 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
8903 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
8904 }
8905 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
8906 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
8907 GC_ADD_FLAGS(str, flags);
8908 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
8909 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
8910 zend_string_release_ex(op2_str, 0);
8911 }
8912 } else {
8913 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
8914 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
8915 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
8916 GC_ADD_FLAGS(str, flags);
8917 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
8918 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8919 zend_string_release_ex(op1_str, 0);
8920 }
8921 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
8922 zend_string_release_ex(op2_str, 0);
8923 }
8924 }
8925 ZEND_VM_NEXT_OPCODE();
8926 } else {
8927 SAVE_OPLINE();
8928
8929 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8930 op1 = ZVAL_UNDEFINED_OP1();
8931 }
8932 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
8933 op2 = ZVAL_UNDEFINED_OP2();
8934 }
8935 concat_function(EX_VAR(opline->result.var), op1, op2);
8936
8937 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8938 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8939 }
8940 }
8941
ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8942 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8943 {
8944 USE_OPLINE
8945 zval *op1, *op2;
8946
8947 SAVE_OPLINE();
8948 op1 = RT_CONSTANT(opline, opline->op1);
8949 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
8950 compare_function(EX_VAR(opline->result.var), op1, op2);
8951
8952 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8953 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8954 }
8955
ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8956 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8957 {
8958 USE_OPLINE
8959 zval *container, *dim, *value;
8960
8961 SAVE_OPLINE();
8962 container = RT_CONSTANT(opline, opline->op1);
8963 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
8964 if (IS_CONST != IS_CONST) {
8965 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
8966 fetch_dim_r_array:
8967 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
8968 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
8969 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
8970 container = Z_REFVAL_P(container);
8971 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
8972 goto fetch_dim_r_array;
8973 } else {
8974 goto fetch_dim_r_slow;
8975 }
8976 } else {
8977 fetch_dim_r_slow:
8978 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
8979 dim++;
8980 }
8981 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
8982 }
8983 } else {
8984 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
8985 }
8986 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8987
8988 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8989 }
8990
ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8991 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8992 {
8993 USE_OPLINE
8994 zval *container;
8995
8996 SAVE_OPLINE();
8997 container = RT_CONSTANT(opline, opline->op1);
8998 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);
8999 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9000
9001 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9002 }
9003
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9004 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9005 {
9006 #if 0
9007 USE_OPLINE
9008 #endif
9009
9010 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9011 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9012 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9013 }
9014 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9015 } else {
9016 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
9017 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9018 }
9019 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9020 }
9021 }
9022
ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9023 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9024 {
9025 USE_OPLINE
9026 zval *container;
9027 void **cache_slot = NULL;
9028
9029 SAVE_OPLINE();
9030 container = RT_CONSTANT(opline, opline->op1);
9031
9032 if (IS_CONST == IS_CONST ||
9033 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9034 do {
9035 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9036 container = Z_REFVAL_P(container);
9037 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9038 break;
9039 }
9040 }
9041 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
9042 ZVAL_UNDEFINED_OP1();
9043 }
9044 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9045 ZVAL_NULL(EX_VAR(opline->result.var));
9046 goto fetch_obj_r_finish;
9047 } while (0);
9048 }
9049
9050 /* here we are sure we are dealing with an object */
9051 do {
9052 zend_object *zobj = Z_OBJ_P(container);
9053 zend_string *name, *tmp_name;
9054 zval *retval;
9055
9056 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9057 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
9058
9059 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9060 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9061
9062 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9063 retval = OBJ_PROP(zobj, prop_offset);
9064 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
9065 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9066 goto fetch_obj_r_copy;
9067 } else {
9068 fetch_obj_r_fast_copy:
9069 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9070 ZEND_VM_NEXT_OPCODE();
9071 }
9072 }
9073 } else if (EXPECTED(zobj->properties != NULL)) {
9074 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9075 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9076 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9077
9078 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9079 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9080
9081 if (EXPECTED(p->key == name) ||
9082 (EXPECTED(p->h == ZSTR_H(name)) &&
9083 EXPECTED(p->key != NULL) &&
9084 EXPECTED(zend_string_equal_content(p->key, name)))) {
9085 retval = &p->val;
9086 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9087 goto fetch_obj_r_copy;
9088 } else {
9089 goto fetch_obj_r_fast_copy;
9090 }
9091 }
9092 }
9093 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9094 }
9095 retval = zend_hash_find_known_hash(zobj->properties, name);
9096 if (EXPECTED(retval)) {
9097 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9098 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9099 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9100 goto fetch_obj_r_copy;
9101 } else {
9102 goto fetch_obj_r_fast_copy;
9103 }
9104 }
9105 }
9106 }
9107 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9108 } else {
9109 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9110 if (UNEXPECTED(!name)) {
9111 ZVAL_UNDEF(EX_VAR(opline->result.var));
9112 break;
9113 }
9114 }
9115
9116 #if ZEND_DEBUG
9117 /* For non-standard object handlers, verify a declared property type in debug builds.
9118 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
9119 zend_property_info *prop_info = NULL;
9120 if (zobj->handlers->read_property != zend_std_read_property) {
9121 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
9122 }
9123 #endif
9124 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
9125 #if ZEND_DEBUG
9126 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
9127 && ZEND_TYPE_IS_SET(prop_info->type)) {
9128 ZVAL_OPT_DEREF(retval);
9129 zend_verify_property_type(prop_info, retval, /* strict */ true);
9130 }
9131 #endif
9132
9133 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9134 zend_tmp_string_release(tmp_name);
9135 }
9136
9137 if (retval != EX_VAR(opline->result.var)) {
9138 fetch_obj_r_copy:
9139 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9140 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9141 zend_unwrap_reference(retval);
9142 }
9143 } while (0);
9144
9145 fetch_obj_r_finish:
9146 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9147
9148 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9149 }
9150
ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9151 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9152 {
9153 USE_OPLINE
9154 zval *container;
9155 void **cache_slot = NULL;
9156
9157 SAVE_OPLINE();
9158 container = RT_CONSTANT(opline, opline->op1);
9159
9160 if (IS_CONST == IS_CONST ||
9161 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9162 do {
9163 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9164 container = Z_REFVAL_P(container);
9165 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9166 break;
9167 }
9168 }
9169 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
9170 ZVAL_UNDEFINED_OP2();
9171 }
9172 ZVAL_NULL(EX_VAR(opline->result.var));
9173 goto fetch_obj_is_finish;
9174 } while (0);
9175 }
9176
9177 /* here we are sure we are dealing with an object */
9178 do {
9179 zend_object *zobj = Z_OBJ_P(container);
9180 zend_string *name, *tmp_name;
9181 zval *retval;
9182
9183 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9184 cache_slot = CACHE_ADDR(opline->extended_value);
9185
9186 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9187 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9188
9189 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9190 retval = OBJ_PROP(zobj, prop_offset);
9191 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
9192 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9193 goto fetch_obj_is_copy;
9194 } else {
9195 fetch_obj_is_fast_copy:
9196 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9197 ZEND_VM_NEXT_OPCODE();
9198 }
9199 }
9200 } else if (EXPECTED(zobj->properties != NULL)) {
9201 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9202 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9203 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9204
9205 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9206 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9207
9208 if (EXPECTED(p->key == name) ||
9209 (EXPECTED(p->h == ZSTR_H(name)) &&
9210 EXPECTED(p->key != NULL) &&
9211 EXPECTED(zend_string_equal_content(p->key, name)))) {
9212 retval = &p->val;
9213 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9214 goto fetch_obj_is_copy;
9215 } else {
9216 goto fetch_obj_is_fast_copy;
9217 }
9218 }
9219 }
9220 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9221 }
9222 retval = zend_hash_find_known_hash(zobj->properties, name);
9223 if (EXPECTED(retval)) {
9224 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9225 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9226 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9227 goto fetch_obj_is_copy;
9228 } else {
9229 goto fetch_obj_is_fast_copy;
9230 }
9231 }
9232 }
9233 }
9234 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9235 } else {
9236 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9237 if (UNEXPECTED(!name)) {
9238 ZVAL_UNDEF(EX_VAR(opline->result.var));
9239 break;
9240 }
9241 }
9242
9243 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
9244
9245 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9246 zend_tmp_string_release(tmp_name);
9247 }
9248
9249 if (retval != EX_VAR(opline->result.var)) {
9250 fetch_obj_is_copy:
9251 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9252 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9253 zend_unwrap_reference(retval);
9254 }
9255 } while (0);
9256
9257 fetch_obj_is_finish:
9258 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9259
9260 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9261 }
9262
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9263 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9264 {
9265 #if 0
9266 USE_OPLINE
9267 #endif
9268
9269 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9270 /* Behave like FETCH_OBJ_W */
9271 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9272 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9273 }
9274 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9275 } else {
9276 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9277 }
9278 }
9279
ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9280 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9281 {
9282 USE_OPLINE
9283 zval *container;
9284
9285 SAVE_OPLINE();
9286 container = RT_CONSTANT(opline, opline->op1);
9287 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);
9288 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9289 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9290 }
9291
ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9292 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9293 {
9294 USE_OPLINE
9295 zval *op1, *op2;
9296 zend_string *op1_str, *op2_str, *str;
9297
9298
9299 op1 = RT_CONSTANT(opline, opline->op1);
9300 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9301 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
9302 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
9303 zend_string *op1_str = Z_STR_P(op1);
9304 zend_string *op2_str = Z_STR_P(op2);
9305 zend_string *str;
9306 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
9307
9308 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9309 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
9310 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
9311 } else {
9312 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9313 }
9314 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9315 zend_string_release_ex(op1_str, 0);
9316 }
9317 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9318 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
9319 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
9320 } else {
9321 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9322 }
9323 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9324 zend_string_release_ex(op2_str, 0);
9325 }
9326 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
9327 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
9328 size_t len = ZSTR_LEN(op1_str);
9329
9330 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
9331 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9332 GC_ADD_FLAGS(str, flags);
9333 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9334 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9335 zend_string_release_ex(op2_str, 0);
9336 }
9337 } else {
9338 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9339 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9340 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9341 GC_ADD_FLAGS(str, flags);
9342 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9343 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9344 zend_string_release_ex(op1_str, 0);
9345 }
9346 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9347 zend_string_release_ex(op2_str, 0);
9348 }
9349 }
9350 ZEND_VM_NEXT_OPCODE();
9351 }
9352
9353 SAVE_OPLINE();
9354 if (IS_CONST == IS_CONST) {
9355 op1_str = Z_STR_P(op1);
9356 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
9357 op1_str = zend_string_copy(Z_STR_P(op1));
9358 } else {
9359 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
9360 ZVAL_UNDEFINED_OP1();
9361 }
9362 op1_str = zval_get_string_func(op1);
9363 }
9364 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9365 op2_str = Z_STR_P(op2);
9366 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
9367 op2_str = zend_string_copy(Z_STR_P(op2));
9368 } else {
9369 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
9370 ZVAL_UNDEFINED_OP2();
9371 }
9372 op2_str = zval_get_string_func(op2);
9373 }
9374 do {
9375 if (IS_CONST != IS_CONST) {
9376 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9377 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9378 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
9379 GC_ADDREF(op2_str);
9380 }
9381 }
9382 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9383 zend_string_release_ex(op1_str, 0);
9384 break;
9385 }
9386 }
9387 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9388 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9389 if (IS_CONST == IS_CONST) {
9390 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
9391 GC_ADDREF(op1_str);
9392 }
9393 }
9394 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9395 zend_string_release_ex(op2_str, 0);
9396 break;
9397 }
9398 }
9399 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9400 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9401 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9402
9403 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
9404 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9405 if (IS_CONST != IS_CONST) {
9406 zend_string_release_ex(op1_str, 0);
9407 }
9408 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9409 zend_string_release_ex(op2_str, 0);
9410 }
9411 } while (0);
9412
9413 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9414 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9415 }
9416
ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9417 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9418 {
9419 USE_OPLINE
9420 zval *function_name;
9421 zval *object;
9422 zend_function *fbc;
9423 zend_class_entry *called_scope;
9424 zend_object *obj;
9425 zend_execute_data *call;
9426 uint32_t call_info;
9427
9428 SAVE_OPLINE();
9429
9430 object = RT_CONSTANT(opline, opline->op1);
9431
9432 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9433 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9434 }
9435
9436 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
9437 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9438 do {
9439 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
9440 function_name = Z_REFVAL_P(function_name);
9441 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
9442 break;
9443 }
9444 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
9445 ZVAL_UNDEFINED_OP2();
9446 if (UNEXPECTED(EG(exception) != NULL)) {
9447
9448 HANDLE_EXCEPTION();
9449 }
9450 }
9451 zend_throw_error(NULL, "Method name must be a string");
9452 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9453
9454 HANDLE_EXCEPTION();
9455 } while (0);
9456 }
9457
9458 if (IS_CONST == IS_UNUSED) {
9459 obj = Z_OBJ_P(object);
9460 } else {
9461 do {
9462 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9463 obj = Z_OBJ_P(object);
9464 } else {
9465 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
9466 zend_reference *ref = Z_REF_P(object);
9467
9468 object = &ref->val;
9469 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9470 obj = Z_OBJ_P(object);
9471 if (IS_CONST & IS_VAR) {
9472 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
9473 efree_size(ref, sizeof(zend_reference));
9474 } else {
9475 Z_ADDREF_P(object);
9476 }
9477 }
9478 break;
9479 }
9480 }
9481 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
9482 object = ZVAL_UNDEFINED_OP1();
9483 if (UNEXPECTED(EG(exception) != NULL)) {
9484 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9485 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9486 }
9487 HANDLE_EXCEPTION();
9488 }
9489 }
9490 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9491 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9492 }
9493 zend_invalid_method_call(object, function_name);
9494 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9495
9496 HANDLE_EXCEPTION();
9497 }
9498 } while (0);
9499 }
9500
9501 called_scope = obj->ce;
9502
9503 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9504 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
9505 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9506 } else {
9507 zend_object *orig_obj = obj;
9508
9509 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9510 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9511 }
9512
9513 /* First, locate the function. */
9514 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));
9515 if (UNEXPECTED(fbc == NULL)) {
9516 if (EXPECTED(!EG(exception))) {
9517 zend_undefined_method(obj->ce, Z_STR_P(function_name));
9518 }
9519 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9520 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
9521 zend_objects_store_del(orig_obj);
9522 }
9523 HANDLE_EXCEPTION();
9524 }
9525 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9526 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
9527 EXPECTED(obj == orig_obj)) {
9528 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
9529 }
9530 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
9531 GC_ADDREF(obj); /* For $this pointer */
9532 if (GC_DELREF(orig_obj) == 0) {
9533 zend_objects_store_del(orig_obj);
9534 }
9535 }
9536 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9537 init_func_run_time_cache(&fbc->op_array);
9538 }
9539 }
9540
9541 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9542 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9543 }
9544
9545 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9546 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
9547 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
9548 zend_objects_store_del(obj);
9549 if (UNEXPECTED(EG(exception))) {
9550 HANDLE_EXCEPTION();
9551 }
9552 }
9553 /* call static method */
9554 obj = (zend_object*)called_scope;
9555 call_info = ZEND_CALL_NESTED_FUNCTION;
9556 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
9557 if (IS_CONST == IS_CV) {
9558 GC_ADDREF(obj); /* For $this pointer */
9559 }
9560 /* CV may be changed indirectly (e.g. when it's a reference) */
9561 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
9562 }
9563
9564 call = zend_vm_stack_push_call_frame(call_info,
9565 fbc, opline->extended_value, obj);
9566 call->prev_execute_data = EX(call);
9567 EX(call) = call;
9568
9569 ZEND_VM_NEXT_OPCODE();
9570 }
9571
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9572 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9573 {
9574 USE_OPLINE
9575 zval *function_name;
9576 zend_class_entry *ce;
9577 uint32_t call_info;
9578 zend_function *fbc;
9579 zend_execute_data *call;
9580
9581 SAVE_OPLINE();
9582
9583 if (IS_CONST == IS_CONST) {
9584 /* no function found. try a static method in class */
9585 ce = CACHED_PTR(opline->result.num);
9586 if (UNEXPECTED(ce == NULL)) {
9587 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);
9588 if (UNEXPECTED(ce == NULL)) {
9589 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9590 HANDLE_EXCEPTION();
9591 }
9592 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9593 CACHE_PTR(opline->result.num, ce);
9594 }
9595 }
9596 } else if (IS_CONST == IS_UNUSED) {
9597 ce = zend_fetch_class(NULL, opline->op1.num);
9598 if (UNEXPECTED(ce == NULL)) {
9599 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9600 HANDLE_EXCEPTION();
9601 }
9602 } else {
9603 ce = Z_CE_P(EX_VAR(opline->op1.var));
9604 }
9605
9606 if (IS_CONST == IS_CONST &&
9607 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9608 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
9609 /* nothing to do */
9610 } else if (IS_CONST != IS_CONST &&
9611 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9612 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
9613 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9614 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
9615 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9616 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9617 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9618 do {
9619 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
9620 function_name = Z_REFVAL_P(function_name);
9621 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
9622 break;
9623 }
9624 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
9625 ZVAL_UNDEFINED_OP2();
9626 if (UNEXPECTED(EG(exception) != NULL)) {
9627 HANDLE_EXCEPTION();
9628 }
9629 }
9630 zend_throw_error(NULL, "Method name must be a string");
9631 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9632 HANDLE_EXCEPTION();
9633 } while (0);
9634 }
9635 }
9636
9637 if (ce->get_static_method) {
9638 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
9639 } else {
9640 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));
9641 }
9642 if (UNEXPECTED(fbc == NULL)) {
9643 if (EXPECTED(!EG(exception))) {
9644 zend_undefined_method(ce, Z_STR_P(function_name));
9645 }
9646 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9647 HANDLE_EXCEPTION();
9648 }
9649 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9650 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
9651 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
9652 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
9653 }
9654 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9655 init_func_run_time_cache(&fbc->op_array);
9656 }
9657 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9658 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9659 }
9660 } else {
9661 if (UNEXPECTED(ce->constructor == NULL)) {
9662 zend_throw_error(NULL, "Cannot call constructor");
9663 HANDLE_EXCEPTION();
9664 }
9665 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
9666 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
9667 HANDLE_EXCEPTION();
9668 }
9669 fbc = ce->constructor;
9670 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9671 init_func_run_time_cache(&fbc->op_array);
9672 }
9673 }
9674
9675 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
9676 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
9677 ce = (zend_class_entry*)Z_OBJ(EX(This));
9678 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9679 } else {
9680 zend_non_static_method_call(fbc);
9681 HANDLE_EXCEPTION();
9682 }
9683 } else {
9684 /* previous opcode is ZEND_FETCH_CLASS */
9685 if (IS_CONST == IS_UNUSED
9686 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
9687 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
9688 if (Z_TYPE(EX(This)) == IS_OBJECT) {
9689 ce = Z_OBJCE(EX(This));
9690 } else {
9691 ce = Z_CE(EX(This));
9692 }
9693 }
9694 call_info = ZEND_CALL_NESTED_FUNCTION;
9695 }
9696
9697 call = zend_vm_stack_push_call_frame(call_info,
9698 fbc, opline->extended_value, ce);
9699 call->prev_execute_data = EX(call);
9700 EX(call) = call;
9701
9702 ZEND_VM_NEXT_OPCODE();
9703 }
9704
ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9705 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9706 {
9707 USE_OPLINE
9708 zval *function_name;
9709 zend_fcall_info_cache fcc;
9710 char *error = NULL;
9711 zend_function *func;
9712 void *object_or_called_scope;
9713 zend_execute_data *call;
9714 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
9715
9716 SAVE_OPLINE();
9717 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9718 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
9719 ZEND_ASSERT(!error);
9720 func = fcc.function_handler;
9721 object_or_called_scope = fcc.called_scope;
9722 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
9723 /* Delay closure destruction until its invocation */
9724 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
9725 call_info |= ZEND_CALL_CLOSURE;
9726 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
9727 call_info |= ZEND_CALL_FAKE_CLOSURE;
9728 }
9729 if (fcc.object) {
9730 object_or_called_scope = fcc.object;
9731 call_info |= ZEND_CALL_HAS_THIS;
9732 }
9733 } else if (fcc.object) {
9734 GC_ADDREF(fcc.object); /* For $this pointer */
9735 object_or_called_scope = fcc.object;
9736 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
9737 }
9738
9739 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9740 if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
9741 if (call_info & ZEND_CALL_CLOSURE) {
9742 zend_object_release(ZEND_CLOSURE_OBJECT(func));
9743 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
9744 zend_object_release(fcc.object);
9745 }
9746 HANDLE_EXCEPTION();
9747 }
9748
9749 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
9750 init_func_run_time_cache(&func->op_array);
9751 }
9752 } else {
9753 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
9754 efree(error);
9755 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9756 HANDLE_EXCEPTION();
9757 }
9758
9759 call = zend_vm_stack_push_call_frame(call_info,
9760 func, opline->extended_value, object_or_called_scope);
9761 call->prev_execute_data = EX(call);
9762 EX(call) = call;
9763
9764 ZEND_VM_NEXT_OPCODE();
9765 }
9766
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9767 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9768 {
9769 USE_OPLINE
9770 zval *expr_ptr, new_expr;
9771
9772 SAVE_OPLINE();
9773 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
9774 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
9775 expr_ptr = zend_get_bad_ptr();
9776 if (Z_ISREF_P(expr_ptr)) {
9777 Z_ADDREF_P(expr_ptr);
9778 } else {
9779 ZVAL_MAKE_REF_EX(expr_ptr, 2);
9780 }
9781
9782 } else {
9783 expr_ptr = RT_CONSTANT(opline, opline->op1);
9784 if (IS_CONST == IS_TMP_VAR) {
9785 /* pass */
9786 } else if (IS_CONST == IS_CONST) {
9787 Z_TRY_ADDREF_P(expr_ptr);
9788 } else if (IS_CONST == IS_CV) {
9789 ZVAL_DEREF(expr_ptr);
9790 Z_TRY_ADDREF_P(expr_ptr);
9791 } else /* if (IS_CONST == IS_VAR) */ {
9792 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
9793 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
9794
9795 expr_ptr = Z_REFVAL_P(expr_ptr);
9796 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
9797 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
9798 expr_ptr = &new_expr;
9799 efree_size(ref, sizeof(zend_reference));
9800 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
9801 Z_ADDREF_P(expr_ptr);
9802 }
9803 }
9804 }
9805 }
9806
9807 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
9808 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9809 zend_string *str;
9810 zend_ulong hval;
9811
9812 add_again:
9813 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
9814 str = Z_STR_P(offset);
9815 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9816 if (ZEND_HANDLE_NUMERIC(str, hval)) {
9817 goto num_index;
9818 }
9819 }
9820 str_index:
9821 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
9822 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
9823 hval = Z_LVAL_P(offset);
9824 num_index:
9825 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
9826 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
9827 offset = Z_REFVAL_P(offset);
9828 goto add_again;
9829 } else if (Z_TYPE_P(offset) == IS_NULL) {
9830 str = ZSTR_EMPTY_ALLOC();
9831 goto str_index;
9832 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
9833 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
9834 goto num_index;
9835 } else if (Z_TYPE_P(offset) == IS_FALSE) {
9836 hval = 0;
9837 goto num_index;
9838 } else if (Z_TYPE_P(offset) == IS_TRUE) {
9839 hval = 1;
9840 goto num_index;
9841 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
9842 zend_use_resource_as_offset(offset);
9843 hval = Z_RES_HANDLE_P(offset);
9844 goto num_index;
9845 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
9846 ZVAL_UNDEFINED_OP2();
9847 str = ZSTR_EMPTY_ALLOC();
9848 goto str_index;
9849 } else {
9850 zend_illegal_array_offset_access(offset);
9851 zval_ptr_dtor_nogc(expr_ptr);
9852 }
9853 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9854 } else {
9855 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
9856 zend_cannot_add_element();
9857 zval_ptr_dtor_nogc(expr_ptr);
9858 }
9859 }
9860 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9861 }
9862
ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9863 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9864 {
9865 zval *array;
9866 uint32_t size;
9867 USE_OPLINE
9868
9869 array = EX_VAR(opline->result.var);
9870 if (IS_CONST != IS_UNUSED) {
9871 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
9872 ZVAL_ARR(array, zend_new_array(size));
9873 /* Explicitly initialize array as not-packed if flag is set */
9874 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
9875 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
9876 }
9877 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9878 } else {
9879 ZVAL_ARR(array, zend_new_array(0));
9880 ZEND_VM_NEXT_OPCODE();
9881 }
9882 }
9883
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9884 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9885 {
9886 USE_OPLINE
9887 zval *container;
9888 bool result;
9889 zend_ulong hval;
9890 zval *offset;
9891
9892 SAVE_OPLINE();
9893 container = RT_CONSTANT(opline, opline->op1);
9894 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9895
9896 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9897 HashTable *ht;
9898 zval *value;
9899 zend_string *str;
9900
9901 isset_dim_obj_array:
9902 ht = Z_ARRVAL_P(container);
9903 isset_again:
9904 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
9905 str = Z_STR_P(offset);
9906 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9907 if (ZEND_HANDLE_NUMERIC(str, hval)) {
9908 goto num_index_prop;
9909 }
9910 }
9911 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
9912 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
9913 hval = Z_LVAL_P(offset);
9914 num_index_prop:
9915 value = zend_hash_index_find(ht, hval);
9916 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
9917 offset = Z_REFVAL_P(offset);
9918 goto isset_again;
9919 } else {
9920 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
9921 if (UNEXPECTED(EG(exception))) {
9922 result = 0;
9923 goto isset_dim_obj_exit;
9924 }
9925 }
9926
9927 if (!(opline->extended_value & ZEND_ISEMPTY)) {
9928 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
9929 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
9930 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
9931
9932 if (IS_CONST & (IS_CONST|IS_CV)) {
9933 /* avoid exception check */
9934 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9935 ZEND_VM_SMART_BRANCH(result, 0);
9936 }
9937 } else {
9938 result = (value == NULL || !i_zend_is_true(value));
9939 }
9940 goto isset_dim_obj_exit;
9941 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
9942 container = Z_REFVAL_P(container);
9943 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9944 goto isset_dim_obj_array;
9945 }
9946 }
9947
9948 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
9949 offset++;
9950 }
9951 if (!(opline->extended_value & ZEND_ISEMPTY)) {
9952 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
9953 } else {
9954 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
9955 }
9956
9957 isset_dim_obj_exit:
9958 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9959
9960 ZEND_VM_SMART_BRANCH(result, 1);
9961 }
9962
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9963 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9964 {
9965 USE_OPLINE
9966 zval *container;
9967 int result;
9968 zval *offset;
9969 zend_string *name, *tmp_name;
9970
9971 SAVE_OPLINE();
9972 container = RT_CONSTANT(opline, opline->op1);
9973 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9974
9975 if (IS_CONST == IS_CONST ||
9976 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9977 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9978 container = Z_REFVAL_P(container);
9979 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
9980 result = (opline->extended_value & ZEND_ISEMPTY);
9981 goto isset_object_finish;
9982 }
9983 } else {
9984 result = (opline->extended_value & ZEND_ISEMPTY);
9985 goto isset_object_finish;
9986 }
9987 }
9988
9989 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9990 name = Z_STR_P(offset);
9991 } else {
9992 name = zval_try_get_tmp_string(offset, &tmp_name);
9993 if (UNEXPECTED(!name)) {
9994 result = 0;
9995 goto isset_object_finish;
9996 }
9997 }
9998
9999 result =
10000 (opline->extended_value & ZEND_ISEMPTY) ^
10001 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));
10002
10003 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10004 zend_tmp_string_release(tmp_name);
10005 }
10006
10007 isset_object_finish:
10008 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10009
10010 ZEND_VM_SMART_BRANCH(result, 1);
10011 }
10012
ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10013 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10014 {
10015 USE_OPLINE
10016
10017 zval *key, *subject;
10018 HashTable *ht;
10019 bool result;
10020
10021 SAVE_OPLINE();
10022
10023 key = RT_CONSTANT(opline, opline->op1);
10024 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10025
10026 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10027 array_key_exists_array:
10028 ht = Z_ARRVAL_P(subject);
10029 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
10030 } else {
10031 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
10032 subject = Z_REFVAL_P(subject);
10033 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10034 goto array_key_exists_array;
10035 }
10036 }
10037 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
10038 result = 0;
10039 }
10040
10041 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10042
10043 ZEND_VM_SMART_BRANCH(result, 1);
10044 }
10045
10046 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10047 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10048 {
10049 USE_OPLINE
10050
10051 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
10052
10053 SAVE_OPLINE();
10054 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
10055 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10056 }
10057
10058 /* Destroy the previously yielded value */
10059 zval_ptr_dtor(&generator->value);
10060
10061 /* Destroy the previously yielded key */
10062 zval_ptr_dtor(&generator->key);
10063
10064 /* Set the new yielded value */
10065 if (IS_CONST != IS_UNUSED) {
10066 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10067 /* Constants and temporary variables aren't yieldable by reference,
10068 * but we still allow them with a notice. */
10069 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
10070 zval *value;
10071
10072 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10073
10074 value = RT_CONSTANT(opline, opline->op1);
10075 ZVAL_COPY_VALUE(&generator->value, value);
10076 if (IS_CONST == IS_CONST) {
10077 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10078 Z_ADDREF(generator->value);
10079 }
10080 }
10081 } else {
10082 zval *value_ptr = zend_get_bad_ptr();
10083
10084 /* If a function call result is yielded and the function did
10085 * not return by reference we throw a notice. */
10086 do {
10087 if (IS_CONST == IS_VAR) {
10088 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
10089 if (opline->extended_value == ZEND_RETURNS_FUNCTION
10090 && !Z_ISREF_P(value_ptr)) {
10091 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10092 ZVAL_COPY(&generator->value, value_ptr);
10093 break;
10094 }
10095 }
10096 if (Z_ISREF_P(value_ptr)) {
10097 Z_ADDREF_P(value_ptr);
10098 } else {
10099 ZVAL_MAKE_REF_EX(value_ptr, 2);
10100 }
10101 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
10102 } while (0);
10103
10104 }
10105 } else {
10106 zval *value = RT_CONSTANT(opline, opline->op1);
10107
10108 /* Consts, temporary variables and references need copying */
10109 if (IS_CONST == IS_CONST) {
10110 ZVAL_COPY_VALUE(&generator->value, value);
10111 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10112 Z_ADDREF(generator->value);
10113 }
10114 } else if (IS_CONST == IS_TMP_VAR) {
10115 ZVAL_COPY_VALUE(&generator->value, value);
10116 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
10117 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
10118
10119 } else {
10120 ZVAL_COPY_VALUE(&generator->value, value);
10121 if (IS_CONST == IS_CV) {
10122 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
10123 }
10124 }
10125 }
10126 } else {
10127 /* If no value was specified yield null */
10128 ZVAL_NULL(&generator->value);
10129 }
10130
10131 /* Set the new yielded key */
10132 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
10133 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10134 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
10135 key = Z_REFVAL_P(key);
10136 }
10137 ZVAL_COPY(&generator->key, key);
10138 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10139
10140 if (Z_TYPE(generator->key) == IS_LONG
10141 && Z_LVAL(generator->key) > generator->largest_used_integer_key
10142 ) {
10143 generator->largest_used_integer_key = Z_LVAL(generator->key);
10144 }
10145 } else {
10146 /* If no key was specified we use auto-increment keys */
10147 generator->largest_used_integer_key++;
10148 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
10149 }
10150
10151 if (RETURN_VALUE_USED(opline)) {
10152 /* If the return value of yield is used set the send
10153 * target and initialize it to NULL */
10154 generator->send_target = EX_VAR(opline->result.var);
10155 ZVAL_NULL(generator->send_target);
10156 } else {
10157 generator->send_target = NULL;
10158 }
10159
10160 /* We increment to the next op, so we are at the correct position when the
10161 * generator is resumed. */
10162 ZEND_VM_INC_OPCODE();
10163
10164 /* The GOTO VM uses a local opline variable. We need to set the opline
10165 * variable in execute_data so we don't resume at an old position. */
10166 SAVE_OPLINE();
10167
10168 ZEND_VM_RETURN();
10169 }
10170
zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)10171 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)
10172 {
10173 USE_OPLINE
10174 zval *varname;
10175 zval *retval;
10176 zend_string *name, *tmp_name;
10177 HashTable *target_symbol_table;
10178
10179 SAVE_OPLINE();
10180 varname = RT_CONSTANT(opline, opline->op1);
10181
10182 if (IS_CONST == IS_CONST) {
10183 name = Z_STR_P(varname);
10184 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
10185 name = Z_STR_P(varname);
10186 tmp_name = NULL;
10187 } else {
10188 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
10189 ZVAL_UNDEFINED_OP1();
10190 }
10191 name = zval_try_get_tmp_string(varname, &tmp_name);
10192 if (UNEXPECTED(!name)) {
10193 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10194
10195 }
10196 ZVAL_UNDEF(EX_VAR(opline->result.var));
10197 HANDLE_EXCEPTION();
10198 }
10199 }
10200
10201 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
10202 retval = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
10203 if (retval == NULL) {
10204 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10205 fetch_this:
10206 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
10207 if (IS_CONST != IS_CONST) {
10208 zend_tmp_string_release(tmp_name);
10209 }
10210 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10211 }
10212 if (type == BP_VAR_W) {
10213 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
10214 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10215 retval = &EG(uninitialized_zval);
10216 } else {
10217 if (IS_CONST == IS_CV) {
10218 /* Keep name alive in case an error handler tries to free it. */
10219 zend_string_addref(name);
10220 }
10221 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10222 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10223 if (type == BP_VAR_RW && !EG(exception)) {
10224 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
10225 } else {
10226 retval = &EG(uninitialized_zval);
10227 }
10228 if (IS_CONST == IS_CV) {
10229 zend_string_release(name);
10230 }
10231 }
10232 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
10233 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
10234 retval = Z_INDIRECT_P(retval);
10235 if (Z_TYPE_P(retval) == IS_UNDEF) {
10236 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10237 goto fetch_this;
10238 }
10239 if (type == BP_VAR_W) {
10240 ZVAL_NULL(retval);
10241 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10242 retval = &EG(uninitialized_zval);
10243 } else {
10244 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10245 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10246 if (type == BP_VAR_RW && !EG(exception)) {
10247 ZVAL_NULL(retval);
10248 } else {
10249 retval = &EG(uninitialized_zval);
10250 }
10251 }
10252 }
10253 }
10254
10255 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10256
10257 }
10258
10259 if (IS_CONST != IS_CONST) {
10260 zend_tmp_string_release(tmp_name);
10261 }
10262
10263 ZEND_ASSERT(retval != NULL);
10264 if (type == BP_VAR_R || type == BP_VAR_IS) {
10265 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
10266 } else {
10267 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
10268 }
10269 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10270 }
10271
ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10272 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10273 {
10274 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10275 }
10276
ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10277 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10278 {
10279 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10280 }
10281
ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10282 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10283 {
10284 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10285 }
10286
ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10287 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10288 {
10289 int fetch_type =
10290 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
10291 BP_VAR_W : BP_VAR_R;
10292 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10293 }
10294
ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10295 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10296 {
10297 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10298 }
10299
ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10300 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10301 {
10302 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10303 }
10304
10305 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10306 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10307 {
10308 #if 0
10309 USE_OPLINE
10310 #endif
10311
10312 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
10313 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
10314 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10315 }
10316 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10317 } else {
10318 if (IS_UNUSED == IS_UNUSED) {
10319 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10320 }
10321 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10322 }
10323 }
10324
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10325 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10326 {
10327 USE_OPLINE
10328 zval *function_name;
10329 zend_class_entry *ce;
10330 uint32_t call_info;
10331 zend_function *fbc;
10332 zend_execute_data *call;
10333
10334 SAVE_OPLINE();
10335
10336 if (IS_CONST == IS_CONST) {
10337 /* no function found. try a static method in class */
10338 ce = CACHED_PTR(opline->result.num);
10339 if (UNEXPECTED(ce == NULL)) {
10340 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);
10341 if (UNEXPECTED(ce == NULL)) {
10342
10343 HANDLE_EXCEPTION();
10344 }
10345 if (IS_UNUSED != IS_CONST) {
10346 CACHE_PTR(opline->result.num, ce);
10347 }
10348 }
10349 } else if (IS_CONST == IS_UNUSED) {
10350 ce = zend_fetch_class(NULL, opline->op1.num);
10351 if (UNEXPECTED(ce == NULL)) {
10352
10353 HANDLE_EXCEPTION();
10354 }
10355 } else {
10356 ce = Z_CE_P(EX_VAR(opline->op1.var));
10357 }
10358
10359 if (IS_CONST == IS_CONST &&
10360 IS_UNUSED == IS_CONST &&
10361 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
10362 /* nothing to do */
10363 } else if (IS_CONST != IS_CONST &&
10364 IS_UNUSED == IS_CONST &&
10365 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
10366 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
10367 } else if (IS_UNUSED != IS_UNUSED) {
10368 function_name = NULL;
10369 if (IS_UNUSED != IS_CONST) {
10370 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
10371 do {
10372 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
10373 function_name = Z_REFVAL_P(function_name);
10374 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
10375 break;
10376 }
10377 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
10378 ZVAL_UNDEFINED_OP2();
10379 if (UNEXPECTED(EG(exception) != NULL)) {
10380 HANDLE_EXCEPTION();
10381 }
10382 }
10383 zend_throw_error(NULL, "Method name must be a string");
10384
10385 HANDLE_EXCEPTION();
10386 } while (0);
10387 }
10388 }
10389
10390 if (ce->get_static_method) {
10391 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
10392 } else {
10393 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
10394 }
10395 if (UNEXPECTED(fbc == NULL)) {
10396 if (EXPECTED(!EG(exception))) {
10397 zend_undefined_method(ce, Z_STR_P(function_name));
10398 }
10399
10400 HANDLE_EXCEPTION();
10401 }
10402 if (IS_UNUSED == IS_CONST &&
10403 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
10404 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
10405 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
10406 }
10407 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10408 init_func_run_time_cache(&fbc->op_array);
10409 }
10410 if (IS_UNUSED != IS_CONST) {
10411
10412 }
10413 } else {
10414 if (UNEXPECTED(ce->constructor == NULL)) {
10415 zend_throw_error(NULL, "Cannot call constructor");
10416 HANDLE_EXCEPTION();
10417 }
10418 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
10419 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
10420 HANDLE_EXCEPTION();
10421 }
10422 fbc = ce->constructor;
10423 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10424 init_func_run_time_cache(&fbc->op_array);
10425 }
10426 }
10427
10428 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
10429 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
10430 ce = (zend_class_entry*)Z_OBJ(EX(This));
10431 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
10432 } else {
10433 zend_non_static_method_call(fbc);
10434 HANDLE_EXCEPTION();
10435 }
10436 } else {
10437 /* previous opcode is ZEND_FETCH_CLASS */
10438 if (IS_CONST == IS_UNUSED
10439 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
10440 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
10441 if (Z_TYPE(EX(This)) == IS_OBJECT) {
10442 ce = Z_OBJCE(EX(This));
10443 } else {
10444 ce = Z_CE(EX(This));
10445 }
10446 }
10447 call_info = ZEND_CALL_NESTED_FUNCTION;
10448 }
10449
10450 call = zend_vm_stack_push_call_frame(call_info,
10451 fbc, opline->extended_value, ce);
10452 call->prev_execute_data = EX(call);
10453 EX(call) = call;
10454
10455 ZEND_VM_NEXT_OPCODE();
10456 }
10457
ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10458 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10459 {
10460 if (IS_CONST == IS_UNUSED) {
10461 SAVE_OPLINE();
10462 zend_verify_missing_return_type(EX(func));
10463 HANDLE_EXCEPTION();
10464 } else {
10465 /* prevents "undefined variable opline" errors */
10466 #if 0 || (IS_CONST != IS_UNUSED)
10467 USE_OPLINE
10468 zval *retval_ref, *retval_ptr;
10469 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
10470 retval_ref = retval_ptr = RT_CONSTANT(opline, opline->op1);
10471
10472 if (IS_CONST == IS_CONST) {
10473 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
10474 retval_ref = retval_ptr = EX_VAR(opline->result.var);
10475 } else if (IS_CONST == IS_VAR) {
10476 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
10477 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
10478 }
10479 ZVAL_DEREF(retval_ptr);
10480 } else if (IS_CONST == IS_CV) {
10481 ZVAL_DEREF(retval_ptr);
10482 }
10483
10484 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
10485 ZEND_VM_NEXT_OPCODE();
10486 }
10487
10488 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
10489 SAVE_OPLINE();
10490 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
10491 if (UNEXPECTED(EG(exception))) {
10492 HANDLE_EXCEPTION();
10493 }
10494 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
10495 ZEND_VM_NEXT_OPCODE();
10496 }
10497 }
10498
10499 zend_reference *ref = NULL;
10500 void *cache_slot = CACHE_ADDR(opline->op2.num);
10501 if (UNEXPECTED(retval_ref != retval_ptr)) {
10502 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10503 ref = Z_REF_P(retval_ref);
10504 } else {
10505 /* A cast might happen - unwrap the reference if this is a by-value return */
10506 if (Z_REFCOUNT_P(retval_ref) == 1) {
10507 ZVAL_UNREF(retval_ref);
10508 } else {
10509 Z_DELREF_P(retval_ref);
10510 ZVAL_COPY(retval_ref, retval_ptr);
10511 }
10512 retval_ptr = retval_ref;
10513 }
10514 }
10515
10516 SAVE_OPLINE();
10517 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
10518 zend_verify_return_error(EX(func), retval_ptr);
10519 HANDLE_EXCEPTION();
10520 }
10521 ZEND_VM_NEXT_OPCODE();
10522 #endif
10523 }
10524 }
10525
ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10526 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10527 {
10528 USE_OPLINE
10529 zval *value, *arg;
10530
10531 if (IS_UNUSED == IS_CONST) {
10532 SAVE_OPLINE();
10533 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10534 uint32_t arg_num;
10535 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10536 if (UNEXPECTED(!arg)) {
10537
10538 HANDLE_EXCEPTION();
10539 }
10540 } else {
10541 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10542 }
10543
10544 value = RT_CONSTANT(opline, opline->op1);
10545 ZVAL_COPY_VALUE(arg, value);
10546 if (IS_CONST == IS_CONST) {
10547 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10548 Z_ADDREF_P(arg);
10549 }
10550 }
10551 ZEND_VM_NEXT_OPCODE();
10552 }
10553
ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10554 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10555 {
10556 USE_OPLINE
10557 zval *value, *arg;
10558 uint32_t arg_num;
10559
10560 if (IS_UNUSED == IS_CONST) {
10561 SAVE_OPLINE();
10562 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10563 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10564 if (UNEXPECTED(!arg)) {
10565
10566 HANDLE_EXCEPTION();
10567 }
10568 } else {
10569 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10570 arg_num = opline->op2.num;
10571 }
10572
10573 if (EXPECTED(0)) {
10574 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10575 goto send_val_by_ref;
10576 }
10577 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10578 send_val_by_ref:
10579 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10580 }
10581 value = RT_CONSTANT(opline, opline->op1);
10582 ZVAL_COPY_VALUE(arg, value);
10583 if (IS_CONST == IS_CONST) {
10584 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10585 Z_ADDREF_P(arg);
10586 }
10587 }
10588 ZEND_VM_NEXT_OPCODE();
10589 }
10590
ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10591 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10592 {
10593 USE_OPLINE
10594 zval *value, *arg;
10595 uint32_t arg_num;
10596
10597 if (IS_UNUSED == IS_CONST) {
10598 SAVE_OPLINE();
10599 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10600 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10601 if (UNEXPECTED(!arg)) {
10602
10603 HANDLE_EXCEPTION();
10604 }
10605 } else {
10606 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10607 arg_num = opline->op2.num;
10608 }
10609
10610 if (EXPECTED(1)) {
10611 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10612 goto send_val_by_ref;
10613 }
10614 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10615 send_val_by_ref:
10616 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10617 }
10618 value = RT_CONSTANT(opline, opline->op1);
10619 ZVAL_COPY_VALUE(arg, value);
10620 if (IS_CONST == IS_CONST) {
10621 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10622 Z_ADDREF_P(arg);
10623 }
10624 }
10625 ZEND_VM_NEXT_OPCODE();
10626 }
10627
ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10628 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10629 {
10630 USE_OPLINE
10631 zval *result;
10632 zend_function *constructor;
10633 zend_class_entry *ce;
10634 zend_execute_data *call;
10635
10636 SAVE_OPLINE();
10637 if (IS_CONST == IS_CONST) {
10638 ce = CACHED_PTR(opline->op2.num);
10639 if (UNEXPECTED(ce == NULL)) {
10640 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);
10641 if (UNEXPECTED(ce == NULL)) {
10642 ZVAL_UNDEF(EX_VAR(opline->result.var));
10643 HANDLE_EXCEPTION();
10644 }
10645 CACHE_PTR(opline->op2.num, ce);
10646 }
10647 } else if (IS_CONST == IS_UNUSED) {
10648 ce = zend_fetch_class(NULL, opline->op1.num);
10649 if (UNEXPECTED(ce == NULL)) {
10650 ZVAL_UNDEF(EX_VAR(opline->result.var));
10651 HANDLE_EXCEPTION();
10652 }
10653 } else {
10654 ce = Z_CE_P(EX_VAR(opline->op1.var));
10655 }
10656
10657 result = EX_VAR(opline->result.var);
10658 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
10659 ZVAL_UNDEF(result);
10660 HANDLE_EXCEPTION();
10661 }
10662
10663 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
10664 if (constructor == NULL) {
10665 if (UNEXPECTED(EG(exception))) {
10666 HANDLE_EXCEPTION();
10667 }
10668
10669 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
10670 * opcode is DO_FCALL in case EXT instructions are used. */
10671 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
10672 ZEND_VM_NEXT_OPCODE_EX(1, 2);
10673 }
10674
10675 /* Perform a dummy function call */
10676 call = zend_vm_stack_push_call_frame(
10677 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
10678 opline->extended_value, NULL);
10679 } else {
10680 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
10681 init_func_run_time_cache(&constructor->op_array);
10682 }
10683 /* We are not handling overloaded classes right now */
10684 call = zend_vm_stack_push_call_frame(
10685 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
10686 constructor,
10687 opline->extended_value,
10688 Z_OBJ_P(result));
10689 Z_ADDREF_P(result);
10690 }
10691
10692 call->prev_execute_data = EX(call);
10693 EX(call) = call;
10694 ZEND_VM_NEXT_OPCODE();
10695 }
10696
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10697 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10698 {
10699 USE_OPLINE
10700 zval *expr_ptr, new_expr;
10701
10702 SAVE_OPLINE();
10703 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
10704 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
10705 expr_ptr = zend_get_bad_ptr();
10706 if (Z_ISREF_P(expr_ptr)) {
10707 Z_ADDREF_P(expr_ptr);
10708 } else {
10709 ZVAL_MAKE_REF_EX(expr_ptr, 2);
10710 }
10711
10712 } else {
10713 expr_ptr = RT_CONSTANT(opline, opline->op1);
10714 if (IS_CONST == IS_TMP_VAR) {
10715 /* pass */
10716 } else if (IS_CONST == IS_CONST) {
10717 Z_TRY_ADDREF_P(expr_ptr);
10718 } else if (IS_CONST == IS_CV) {
10719 ZVAL_DEREF(expr_ptr);
10720 Z_TRY_ADDREF_P(expr_ptr);
10721 } else /* if (IS_CONST == IS_VAR) */ {
10722 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
10723 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
10724
10725 expr_ptr = Z_REFVAL_P(expr_ptr);
10726 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
10727 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
10728 expr_ptr = &new_expr;
10729 efree_size(ref, sizeof(zend_reference));
10730 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
10731 Z_ADDREF_P(expr_ptr);
10732 }
10733 }
10734 }
10735 }
10736
10737 if (IS_UNUSED != IS_UNUSED) {
10738 zval *offset = NULL;
10739 zend_string *str;
10740 zend_ulong hval;
10741
10742 add_again:
10743 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10744 str = Z_STR_P(offset);
10745 if (IS_UNUSED != IS_CONST) {
10746 if (ZEND_HANDLE_NUMERIC(str, hval)) {
10747 goto num_index;
10748 }
10749 }
10750 str_index:
10751 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
10752 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
10753 hval = Z_LVAL_P(offset);
10754 num_index:
10755 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
10756 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
10757 offset = Z_REFVAL_P(offset);
10758 goto add_again;
10759 } else if (Z_TYPE_P(offset) == IS_NULL) {
10760 str = ZSTR_EMPTY_ALLOC();
10761 goto str_index;
10762 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
10763 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
10764 goto num_index;
10765 } else if (Z_TYPE_P(offset) == IS_FALSE) {
10766 hval = 0;
10767 goto num_index;
10768 } else if (Z_TYPE_P(offset) == IS_TRUE) {
10769 hval = 1;
10770 goto num_index;
10771 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
10772 zend_use_resource_as_offset(offset);
10773 hval = Z_RES_HANDLE_P(offset);
10774 goto num_index;
10775 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
10776 ZVAL_UNDEFINED_OP2();
10777 str = ZSTR_EMPTY_ALLOC();
10778 goto str_index;
10779 } else {
10780 zend_illegal_array_offset_access(offset);
10781 zval_ptr_dtor_nogc(expr_ptr);
10782 }
10783
10784 } else {
10785 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
10786 zend_cannot_add_element();
10787 zval_ptr_dtor_nogc(expr_ptr);
10788 }
10789 }
10790 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10791 }
10792
ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10793 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10794 {
10795 zval *array;
10796 uint32_t size;
10797 USE_OPLINE
10798
10799 array = EX_VAR(opline->result.var);
10800 if (IS_CONST != IS_UNUSED) {
10801 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
10802 ZVAL_ARR(array, zend_new_array(size));
10803 /* Explicitly initialize array as not-packed if flag is set */
10804 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
10805 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
10806 }
10807 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10808 } else {
10809 ZVAL_ARR(array, zend_new_array(0));
10810 ZEND_VM_NEXT_OPCODE();
10811 }
10812 }
10813
ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10814 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10815 {
10816 USE_OPLINE
10817 zval *varname;
10818 zend_string *name, *tmp_name;
10819 HashTable *target_symbol_table;
10820
10821 SAVE_OPLINE();
10822
10823 varname = RT_CONSTANT(opline, opline->op1);
10824
10825 if (IS_CONST == IS_CONST) {
10826 name = Z_STR_P(varname);
10827 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
10828 name = Z_STR_P(varname);
10829 tmp_name = NULL;
10830 } else {
10831 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
10832 varname = ZVAL_UNDEFINED_OP1();
10833 }
10834 name = zval_try_get_tmp_string(varname, &tmp_name);
10835 if (UNEXPECTED(!name)) {
10836
10837 HANDLE_EXCEPTION();
10838 }
10839 }
10840
10841 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
10842 zend_hash_del_ind(target_symbol_table, name);
10843
10844 if (IS_CONST != IS_CONST) {
10845 zend_tmp_string_release(tmp_name);
10846 }
10847
10848 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10849 }
10850
10851 /* 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)10852 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10853 {
10854 USE_OPLINE
10855 zval *value;
10856 /* Should be bool result? as below got: result = (opline->extended_value & ZEND_ISEMPTY) */
10857 int result;
10858 zval *varname;
10859 zend_string *name, *tmp_name;
10860 HashTable *target_symbol_table;
10861
10862 SAVE_OPLINE();
10863 varname = RT_CONSTANT(opline, opline->op1);
10864 if (IS_CONST == IS_CONST) {
10865 name = Z_STR_P(varname);
10866 } else {
10867 name = zval_get_tmp_string(varname, &tmp_name);
10868 }
10869
10870 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
10871 value = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
10872
10873 if (IS_CONST != IS_CONST) {
10874 zend_tmp_string_release(tmp_name);
10875 }
10876
10877 if (!value) {
10878 result = (opline->extended_value & ZEND_ISEMPTY);
10879 } else {
10880 if (Z_TYPE_P(value) == IS_INDIRECT) {
10881 value = Z_INDIRECT_P(value);
10882 }
10883 if (!(opline->extended_value & ZEND_ISEMPTY)) {
10884 if (Z_ISREF_P(value)) {
10885 value = Z_REFVAL_P(value);
10886 }
10887 result = Z_TYPE_P(value) > IS_NULL;
10888 } else {
10889 result = !i_zend_is_true(value);
10890 }
10891 }
10892
10893 ZEND_VM_SMART_BRANCH(result, 1);
10894 }
10895
10896 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10897 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10898 {
10899 USE_OPLINE
10900
10901 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
10902
10903 SAVE_OPLINE();
10904 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
10905 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10906 }
10907
10908 /* Destroy the previously yielded value */
10909 zval_ptr_dtor(&generator->value);
10910
10911 /* Destroy the previously yielded key */
10912 zval_ptr_dtor(&generator->key);
10913
10914 /* Set the new yielded value */
10915 if (IS_CONST != IS_UNUSED) {
10916 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10917 /* Constants and temporary variables aren't yieldable by reference,
10918 * but we still allow them with a notice. */
10919 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
10920 zval *value;
10921
10922 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10923
10924 value = RT_CONSTANT(opline, opline->op1);
10925 ZVAL_COPY_VALUE(&generator->value, value);
10926 if (IS_CONST == IS_CONST) {
10927 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10928 Z_ADDREF(generator->value);
10929 }
10930 }
10931 } else {
10932 zval *value_ptr = zend_get_bad_ptr();
10933
10934 /* If a function call result is yielded and the function did
10935 * not return by reference we throw a notice. */
10936 do {
10937 if (IS_CONST == IS_VAR) {
10938 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
10939 if (opline->extended_value == ZEND_RETURNS_FUNCTION
10940 && !Z_ISREF_P(value_ptr)) {
10941 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10942 ZVAL_COPY(&generator->value, value_ptr);
10943 break;
10944 }
10945 }
10946 if (Z_ISREF_P(value_ptr)) {
10947 Z_ADDREF_P(value_ptr);
10948 } else {
10949 ZVAL_MAKE_REF_EX(value_ptr, 2);
10950 }
10951 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
10952 } while (0);
10953
10954 }
10955 } else {
10956 zval *value = RT_CONSTANT(opline, opline->op1);
10957
10958 /* Consts, temporary variables and references need copying */
10959 if (IS_CONST == IS_CONST) {
10960 ZVAL_COPY_VALUE(&generator->value, value);
10961 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10962 Z_ADDREF(generator->value);
10963 }
10964 } else if (IS_CONST == IS_TMP_VAR) {
10965 ZVAL_COPY_VALUE(&generator->value, value);
10966 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
10967 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
10968
10969 } else {
10970 ZVAL_COPY_VALUE(&generator->value, value);
10971 if (IS_CONST == IS_CV) {
10972 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
10973 }
10974 }
10975 }
10976 } else {
10977 /* If no value was specified yield null */
10978 ZVAL_NULL(&generator->value);
10979 }
10980
10981 /* Set the new yielded key */
10982 if (IS_UNUSED != IS_UNUSED) {
10983 zval *key = NULL;
10984 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
10985 key = Z_REFVAL_P(key);
10986 }
10987 ZVAL_COPY(&generator->key, key);
10988
10989 if (Z_TYPE(generator->key) == IS_LONG
10990 && Z_LVAL(generator->key) > generator->largest_used_integer_key
10991 ) {
10992 generator->largest_used_integer_key = Z_LVAL(generator->key);
10993 }
10994 } else {
10995 /* If no key was specified we use auto-increment keys */
10996 generator->largest_used_integer_key++;
10997 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
10998 }
10999
11000 if (RETURN_VALUE_USED(opline)) {
11001 /* If the return value of yield is used set the send
11002 * target and initialize it to NULL */
11003 generator->send_target = EX_VAR(opline->result.var);
11004 ZVAL_NULL(generator->send_target);
11005 } else {
11006 generator->send_target = NULL;
11007 }
11008
11009 /* We increment to the next op, so we are at the correct position when the
11010 * generator is resumed. */
11011 ZEND_VM_INC_OPCODE();
11012
11013 /* The GOTO VM uses a local opline variable. We need to set the opline
11014 * variable in execute_data so we don't resume at an old position. */
11015 SAVE_OPLINE();
11016
11017 ZEND_VM_RETURN();
11018 }
11019
ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11020 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11021 {
11022 USE_OPLINE
11023 zval *op;
11024
11025 SAVE_OPLINE();
11026 op = RT_CONSTANT(opline, opline->op1);
11027 zend_match_unhandled_error(op);
11028 HANDLE_EXCEPTION();
11029 }
11030
ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11031 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11032 {
11033 USE_OPLINE
11034 zval *op1;
11035 zend_long count;
11036
11037 SAVE_OPLINE();
11038 op1 = RT_CONSTANT(opline, opline->op1);
11039
11040 while (1) {
11041 if (Z_TYPE_P(op1) == IS_ARRAY) {
11042 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
11043 break;
11044 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
11045 zend_object *zobj = Z_OBJ_P(op1);
11046
11047 /* first, we check if the handler is defined */
11048 if (zobj->handlers->count_elements) {
11049 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
11050 break;
11051 }
11052 if (UNEXPECTED(EG(exception))) {
11053 count = 0;
11054 break;
11055 }
11056 }
11057
11058 /* if not and the object implements Countable we call its count() method */
11059 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
11060 zval retval;
11061
11062 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
11063 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
11064 count = zval_get_long(&retval);
11065 zval_ptr_dtor(&retval);
11066 break;
11067 }
11068
11069 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
11070 } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11071 op1 = Z_REFVAL_P(op1);
11072 continue;
11073 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11074 ZVAL_UNDEFINED_OP1();
11075 }
11076 count = 0;
11077 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));
11078 break;
11079 }
11080
11081 ZVAL_LONG(EX_VAR(opline->result.var), count);
11082
11083 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11084 }
11085
ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11086 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11087 {
11088 USE_OPLINE
11089
11090 if (IS_CONST == IS_UNUSED) {
11091 SAVE_OPLINE();
11092 if (UNEXPECTED(!EX(func)->common.scope)) {
11093 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
11094 ZVAL_UNDEF(EX_VAR(opline->result.var));
11095 HANDLE_EXCEPTION();
11096 } else {
11097 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
11098 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
11099 if (UNEXPECTED(EG(exception))) {
11100 HANDLE_EXCEPTION();
11101 }
11102 ZEND_VM_NEXT_OPCODE();
11103 }
11104 } else {
11105 zval *op1;
11106
11107 SAVE_OPLINE();
11108 op1 = RT_CONSTANT(opline, opline->op1);
11109 while (1) {
11110 if (Z_TYPE_P(op1) == IS_OBJECT) {
11111 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
11112 } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11113 op1 = Z_REFVAL_P(op1);
11114 continue;
11115 } else {
11116 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11117 ZVAL_UNDEFINED_OP1();
11118 }
11119 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
11120 ZVAL_UNDEF(EX_VAR(opline->result.var));
11121 }
11122 break;
11123 }
11124
11125 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11126 }
11127 }
11128
ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11129 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11130 {
11131 USE_OPLINE
11132 zval *op1;
11133 zend_string *type;
11134
11135 SAVE_OPLINE();
11136 op1 = RT_CONSTANT(opline, opline->op1);
11137 type = zend_zval_get_legacy_type(op1);
11138 if (EXPECTED(type)) {
11139 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
11140 } else {
11141 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
11142 }
11143
11144 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11145 }
11146
ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11147 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11148 {
11149 USE_OPLINE
11150 zend_array *ht;
11151 uint32_t arg_count, result_size, skip;
11152
11153 arg_count = EX_NUM_ARGS();
11154 if (IS_CONST == IS_CONST) {
11155 skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
11156 if (arg_count < skip) {
11157 result_size = 0;
11158 } else {
11159 result_size = arg_count - skip;
11160 }
11161 } else {
11162 skip = 0;
11163 result_size = arg_count;
11164 }
11165
11166 if (result_size) {
11167 SAVE_OPLINE();
11168 uint32_t first_extra_arg = EX(func)->op_array.num_args;
11169
11170 ht = zend_new_array(result_size);
11171 ZVAL_ARR(EX_VAR(opline->result.var), ht);
11172 zend_hash_real_init_packed(ht);
11173 ZEND_HASH_FILL_PACKED(ht) {
11174 zval *p, *q;
11175 uint32_t i = skip;
11176 p = EX_VAR_NUM(i);
11177 if (arg_count > first_extra_arg) {
11178 while (i < first_extra_arg) {
11179 q = p;
11180 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11181 ZVAL_DEREF(q);
11182 if (Z_OPT_REFCOUNTED_P(q)) {
11183 Z_ADDREF_P(q);
11184 }
11185 ZEND_HASH_FILL_SET(q);
11186 } else {
11187 ZEND_HASH_FILL_SET_NULL();
11188 }
11189 ZEND_HASH_FILL_NEXT();
11190 p++;
11191 i++;
11192 }
11193 if (skip < first_extra_arg) {
11194 skip = 0;
11195 } else {
11196 skip -= first_extra_arg;
11197 }
11198 p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
11199 }
11200 while (i < arg_count) {
11201 q = p;
11202 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11203 ZVAL_DEREF(q);
11204 if (Z_OPT_REFCOUNTED_P(q)) {
11205 Z_ADDREF_P(q);
11206 }
11207 ZEND_HASH_FILL_SET(q);
11208 } else {
11209 ZEND_HASH_FILL_SET_NULL();
11210 }
11211 ZEND_HASH_FILL_NEXT();
11212 p++;
11213 i++;
11214 }
11215 } ZEND_HASH_FILL_END();
11216 ht->nNumOfElements = result_size;
11217 } else {
11218 ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
11219 }
11220 ZEND_VM_NEXT_OPCODE();
11221 }
11222
11223 /* Contrary to what its name indicates, ZEND_COPY_TMP may receive and define references. */
ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11224 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11225 {
11226 USE_OPLINE
11227 zval *op1, *op2;
11228
11229 SAVE_OPLINE();
11230 op1 = RT_CONSTANT(opline, opline->op1);
11231 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11232 div_function(EX_VAR(opline->result.var), op1, op2);
11233
11234
11235 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11236 }
11237
ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11238 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11239 {
11240 USE_OPLINE
11241 zval *op1, *op2;
11242
11243 SAVE_OPLINE();
11244 op1 = RT_CONSTANT(opline, opline->op1);
11245 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11246 pow_function(EX_VAR(opline->result.var), op1, op2);
11247
11248
11249 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11250 }
11251
ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11252 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11253 {
11254 USE_OPLINE
11255 zval *op1, *op2;
11256
11257 op1 = RT_CONSTANT(opline, opline->op1);
11258 op2 = EX_VAR(opline->op2.var);
11259
11260 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
11261 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
11262 zend_string *op1_str = Z_STR_P(op1);
11263 zend_string *op2_str = Z_STR_P(op2);
11264 zend_string *str;
11265 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
11266
11267 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
11268 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
11269 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
11270 } else {
11271 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
11272 }
11273 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11274 zend_string_release_ex(op1_str, 0);
11275 }
11276 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
11277 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
11278 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
11279 } else {
11280 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
11281 }
11282 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11283 zend_string_release_ex(op2_str, 0);
11284 }
11285 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
11286 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
11287 size_t len = ZSTR_LEN(op1_str);
11288
11289 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
11290 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
11291 }
11292 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
11293 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11294 GC_ADD_FLAGS(str, flags);
11295 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11296 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11297 zend_string_release_ex(op2_str, 0);
11298 }
11299 } else {
11300 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
11301 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
11302 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11303 GC_ADD_FLAGS(str, flags);
11304 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11305 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11306 zend_string_release_ex(op1_str, 0);
11307 }
11308 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11309 zend_string_release_ex(op2_str, 0);
11310 }
11311 }
11312 ZEND_VM_NEXT_OPCODE();
11313 } else {
11314 SAVE_OPLINE();
11315
11316 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11317 op1 = ZVAL_UNDEFINED_OP1();
11318 }
11319 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
11320 op2 = ZVAL_UNDEFINED_OP2();
11321 }
11322 concat_function(EX_VAR(opline->result.var), op1, op2);
11323
11324
11325 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11326 }
11327 }
11328
ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11329 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11330 {
11331 USE_OPLINE
11332 zval *op1, *op2;
11333
11334 SAVE_OPLINE();
11335 op1 = RT_CONSTANT(opline, opline->op1);
11336 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11337 compare_function(EX_VAR(opline->result.var), op1, op2);
11338
11339
11340 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11341 }
11342
ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11343 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11344 {
11345 USE_OPLINE
11346 zval *container, *dim, *value;
11347
11348 SAVE_OPLINE();
11349 container = RT_CONSTANT(opline, opline->op1);
11350 dim = EX_VAR(opline->op2.var);
11351 if (IS_CONST != IS_CONST) {
11352 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11353 fetch_dim_r_array:
11354 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
11355 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
11356 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
11357 container = Z_REFVAL_P(container);
11358 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11359 goto fetch_dim_r_array;
11360 } else {
11361 goto fetch_dim_r_slow;
11362 }
11363 } else {
11364 fetch_dim_r_slow:
11365 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
11366 dim++;
11367 }
11368 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
11369 }
11370 } else {
11371 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
11372 }
11373
11374
11375 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11376 }
11377
ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11378 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11379 {
11380 USE_OPLINE
11381 zval *container;
11382
11383 SAVE_OPLINE();
11384 container = RT_CONSTANT(opline, opline->op1);
11385 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
11386
11387
11388 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11389 }
11390
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11391 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11392 {
11393 #if 0
11394 USE_OPLINE
11395 #endif
11396
11397 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
11398 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
11399 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11400 }
11401 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11402 } else {
11403 if (IS_CV == IS_UNUSED) {
11404 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11405 }
11406 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11407 }
11408 }
11409
ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11410 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11411 {
11412 USE_OPLINE
11413 zval *container;
11414 void **cache_slot = NULL;
11415
11416 SAVE_OPLINE();
11417 container = RT_CONSTANT(opline, opline->op1);
11418
11419 if (IS_CONST == IS_CONST ||
11420 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
11421 do {
11422 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
11423 container = Z_REFVAL_P(container);
11424 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
11425 break;
11426 }
11427 }
11428 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
11429 ZVAL_UNDEFINED_OP1();
11430 }
11431 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11432 ZVAL_NULL(EX_VAR(opline->result.var));
11433 goto fetch_obj_r_finish;
11434 } while (0);
11435 }
11436
11437 /* here we are sure we are dealing with an object */
11438 do {
11439 zend_object *zobj = Z_OBJ_P(container);
11440 zend_string *name, *tmp_name;
11441 zval *retval;
11442
11443 if (IS_CV == IS_CONST) {
11444 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
11445
11446 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
11447 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
11448
11449 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
11450 retval = OBJ_PROP(zobj, prop_offset);
11451 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
11452 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11453 goto fetch_obj_r_copy;
11454 } else {
11455 fetch_obj_r_fast_copy:
11456 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11457 ZEND_VM_NEXT_OPCODE();
11458 }
11459 }
11460 } else if (EXPECTED(zobj->properties != NULL)) {
11461 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11462 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
11463 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
11464
11465 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
11466 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
11467
11468 if (EXPECTED(p->key == name) ||
11469 (EXPECTED(p->h == ZSTR_H(name)) &&
11470 EXPECTED(p->key != NULL) &&
11471 EXPECTED(zend_string_equal_content(p->key, name)))) {
11472 retval = &p->val;
11473 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11474 goto fetch_obj_r_copy;
11475 } else {
11476 goto fetch_obj_r_fast_copy;
11477 }
11478 }
11479 }
11480 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
11481 }
11482 retval = zend_hash_find_known_hash(zobj->properties, name);
11483 if (EXPECTED(retval)) {
11484 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
11485 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
11486 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11487 goto fetch_obj_r_copy;
11488 } else {
11489 goto fetch_obj_r_fast_copy;
11490 }
11491 }
11492 }
11493 }
11494 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11495 } else {
11496 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
11497 if (UNEXPECTED(!name)) {
11498 ZVAL_UNDEF(EX_VAR(opline->result.var));
11499 break;
11500 }
11501 }
11502
11503 #if ZEND_DEBUG
11504 /* For non-standard object handlers, verify a declared property type in debug builds.
11505 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
11506 zend_property_info *prop_info = NULL;
11507 if (zobj->handlers->read_property != zend_std_read_property) {
11508 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
11509 }
11510 #endif
11511 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
11512 #if ZEND_DEBUG
11513 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
11514 && ZEND_TYPE_IS_SET(prop_info->type)) {
11515 ZVAL_OPT_DEREF(retval);
11516 zend_verify_property_type(prop_info, retval, /* strict */ true);
11517 }
11518 #endif
11519
11520 if (IS_CV != IS_CONST) {
11521 zend_tmp_string_release(tmp_name);
11522 }
11523
11524 if (retval != EX_VAR(opline->result.var)) {
11525 fetch_obj_r_copy:
11526 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11527 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
11528 zend_unwrap_reference(retval);
11529 }
11530 } while (0);
11531
11532 fetch_obj_r_finish:
11533
11534
11535 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11536 }
11537
ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11538 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11539 {
11540 USE_OPLINE
11541 zval *container;
11542 void **cache_slot = NULL;
11543
11544 SAVE_OPLINE();
11545 container = RT_CONSTANT(opline, opline->op1);
11546
11547 if (IS_CONST == IS_CONST ||
11548 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
11549 do {
11550 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
11551 container = Z_REFVAL_P(container);
11552 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
11553 break;
11554 }
11555 }
11556 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
11557 ZVAL_UNDEFINED_OP2();
11558 }
11559 ZVAL_NULL(EX_VAR(opline->result.var));
11560 goto fetch_obj_is_finish;
11561 } while (0);
11562 }
11563
11564 /* here we are sure we are dealing with an object */
11565 do {
11566 zend_object *zobj = Z_OBJ_P(container);
11567 zend_string *name, *tmp_name;
11568 zval *retval;
11569
11570 if (IS_CV == IS_CONST) {
11571 cache_slot = CACHE_ADDR(opline->extended_value);
11572
11573 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
11574 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
11575
11576 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
11577 retval = OBJ_PROP(zobj, prop_offset);
11578 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
11579 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11580 goto fetch_obj_is_copy;
11581 } else {
11582 fetch_obj_is_fast_copy:
11583 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11584 ZEND_VM_NEXT_OPCODE();
11585 }
11586 }
11587 } else if (EXPECTED(zobj->properties != NULL)) {
11588 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11589 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
11590 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
11591
11592 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
11593 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
11594
11595 if (EXPECTED(p->key == name) ||
11596 (EXPECTED(p->h == ZSTR_H(name)) &&
11597 EXPECTED(p->key != NULL) &&
11598 EXPECTED(zend_string_equal_content(p->key, name)))) {
11599 retval = &p->val;
11600 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11601 goto fetch_obj_is_copy;
11602 } else {
11603 goto fetch_obj_is_fast_copy;
11604 }
11605 }
11606 }
11607 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
11608 }
11609 retval = zend_hash_find_known_hash(zobj->properties, name);
11610 if (EXPECTED(retval)) {
11611 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
11612 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
11613 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11614 goto fetch_obj_is_copy;
11615 } else {
11616 goto fetch_obj_is_fast_copy;
11617 }
11618 }
11619 }
11620 }
11621 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11622 } else {
11623 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
11624 if (UNEXPECTED(!name)) {
11625 ZVAL_UNDEF(EX_VAR(opline->result.var));
11626 break;
11627 }
11628 }
11629
11630 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
11631
11632 if (IS_CV != IS_CONST) {
11633 zend_tmp_string_release(tmp_name);
11634 }
11635
11636 if (retval != EX_VAR(opline->result.var)) {
11637 fetch_obj_is_copy:
11638 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11639 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
11640 zend_unwrap_reference(retval);
11641 }
11642 } while (0);
11643
11644 fetch_obj_is_finish:
11645
11646
11647 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11648 }
11649
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11650 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11651 {
11652 #if 0
11653 USE_OPLINE
11654 #endif
11655
11656 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
11657 /* Behave like FETCH_OBJ_W */
11658 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
11659 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11660 }
11661 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11662 } else {
11663 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11664 }
11665 }
11666
ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11667 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11668 {
11669 USE_OPLINE
11670 zval *container;
11671
11672 SAVE_OPLINE();
11673 container = RT_CONSTANT(opline, opline->op1);
11674 zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
11675
11676 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11677 }
11678
ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11679 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11680 {
11681 USE_OPLINE
11682 zval *op1, *op2;
11683 zend_string *op1_str, *op2_str, *str;
11684
11685
11686 op1 = RT_CONSTANT(opline, opline->op1);
11687 op2 = EX_VAR(opline->op2.var);
11688 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
11689 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
11690 zend_string *op1_str = Z_STR_P(op1);
11691 zend_string *op2_str = Z_STR_P(op2);
11692 zend_string *str;
11693 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
11694
11695 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
11696 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
11697 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
11698 } else {
11699 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
11700 }
11701 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11702 zend_string_release_ex(op1_str, 0);
11703 }
11704 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
11705 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
11706 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
11707 } else {
11708 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
11709 }
11710 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11711 zend_string_release_ex(op2_str, 0);
11712 }
11713 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
11714 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
11715 size_t len = ZSTR_LEN(op1_str);
11716
11717 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
11718 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11719 GC_ADD_FLAGS(str, flags);
11720 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11721 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11722 zend_string_release_ex(op2_str, 0);
11723 }
11724 } else {
11725 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
11726 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
11727 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11728 GC_ADD_FLAGS(str, flags);
11729 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11730 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11731 zend_string_release_ex(op1_str, 0);
11732 }
11733 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11734 zend_string_release_ex(op2_str, 0);
11735 }
11736 }
11737 ZEND_VM_NEXT_OPCODE();
11738 }
11739
11740 SAVE_OPLINE();
11741 if (IS_CONST == IS_CONST) {
11742 op1_str = Z_STR_P(op1);
11743 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
11744 op1_str = zend_string_copy(Z_STR_P(op1));
11745 } else {
11746 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11747 ZVAL_UNDEFINED_OP1();
11748 }
11749 op1_str = zval_get_string_func(op1);
11750 }
11751 if (IS_CV == IS_CONST) {
11752 op2_str = Z_STR_P(op2);
11753 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
11754 op2_str = zend_string_copy(Z_STR_P(op2));
11755 } else {
11756 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
11757 ZVAL_UNDEFINED_OP2();
11758 }
11759 op2_str = zval_get_string_func(op2);
11760 }
11761 do {
11762 if (IS_CONST != IS_CONST) {
11763 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
11764 if (IS_CV == IS_CONST) {
11765 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
11766 GC_ADDREF(op2_str);
11767 }
11768 }
11769 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
11770 zend_string_release_ex(op1_str, 0);
11771 break;
11772 }
11773 }
11774 if (IS_CV != IS_CONST) {
11775 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
11776 if (IS_CONST == IS_CONST) {
11777 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
11778 GC_ADDREF(op1_str);
11779 }
11780 }
11781 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
11782 zend_string_release_ex(op2_str, 0);
11783 break;
11784 }
11785 }
11786 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
11787 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
11788 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11789
11790 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
11791 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11792 if (IS_CONST != IS_CONST) {
11793 zend_string_release_ex(op1_str, 0);
11794 }
11795 if (IS_CV != IS_CONST) {
11796 zend_string_release_ex(op2_str, 0);
11797 }
11798 } while (0);
11799
11800
11801 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11802 }
11803
ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11804 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11805 {
11806 USE_OPLINE
11807 zval *function_name;
11808 zval *object;
11809 zend_function *fbc;
11810 zend_class_entry *called_scope;
11811 zend_object *obj;
11812 zend_execute_data *call;
11813 uint32_t call_info;
11814
11815 SAVE_OPLINE();
11816
11817 object = RT_CONSTANT(opline, opline->op1);
11818
11819 if (IS_CV != IS_CONST) {
11820 function_name = EX_VAR(opline->op2.var);
11821 }
11822
11823 if (IS_CV != IS_CONST &&
11824 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
11825 do {
11826 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
11827 function_name = Z_REFVAL_P(function_name);
11828 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
11829 break;
11830 }
11831 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
11832 ZVAL_UNDEFINED_OP2();
11833 if (UNEXPECTED(EG(exception) != NULL)) {
11834
11835 HANDLE_EXCEPTION();
11836 }
11837 }
11838 zend_throw_error(NULL, "Method name must be a string");
11839
11840
11841 HANDLE_EXCEPTION();
11842 } while (0);
11843 }
11844
11845 if (IS_CONST == IS_UNUSED) {
11846 obj = Z_OBJ_P(object);
11847 } else {
11848 do {
11849 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
11850 obj = Z_OBJ_P(object);
11851 } else {
11852 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
11853 zend_reference *ref = Z_REF_P(object);
11854
11855 object = &ref->val;
11856 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
11857 obj = Z_OBJ_P(object);
11858 if (IS_CONST & IS_VAR) {
11859 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
11860 efree_size(ref, sizeof(zend_reference));
11861 } else {
11862 Z_ADDREF_P(object);
11863 }
11864 }
11865 break;
11866 }
11867 }
11868 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
11869 object = ZVAL_UNDEFINED_OP1();
11870 if (UNEXPECTED(EG(exception) != NULL)) {
11871 if (IS_CV != IS_CONST) {
11872
11873 }
11874 HANDLE_EXCEPTION();
11875 }
11876 }
11877 if (IS_CV == IS_CONST) {
11878 function_name = EX_VAR(opline->op2.var);
11879 }
11880 zend_invalid_method_call(object, function_name);
11881
11882
11883 HANDLE_EXCEPTION();
11884 }
11885 } while (0);
11886 }
11887
11888 called_scope = obj->ce;
11889
11890 if (IS_CV == IS_CONST &&
11891 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
11892 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
11893 } else {
11894 zend_object *orig_obj = obj;
11895
11896 if (IS_CV == IS_CONST) {
11897 function_name = EX_VAR(opline->op2.var);
11898 }
11899
11900 /* First, locate the function. */
11901 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
11902 if (UNEXPECTED(fbc == NULL)) {
11903 if (EXPECTED(!EG(exception))) {
11904 zend_undefined_method(obj->ce, Z_STR_P(function_name));
11905 }
11906
11907 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
11908 zend_objects_store_del(orig_obj);
11909 }
11910 HANDLE_EXCEPTION();
11911 }
11912 if (IS_CV == IS_CONST &&
11913 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
11914 EXPECTED(obj == orig_obj)) {
11915 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
11916 }
11917 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
11918 GC_ADDREF(obj); /* For $this pointer */
11919 if (GC_DELREF(orig_obj) == 0) {
11920 zend_objects_store_del(orig_obj);
11921 }
11922 }
11923 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
11924 init_func_run_time_cache(&fbc->op_array);
11925 }
11926 }
11927
11928 if (IS_CV != IS_CONST) {
11929
11930 }
11931
11932 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
11933 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
11934 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
11935 zend_objects_store_del(obj);
11936 if (UNEXPECTED(EG(exception))) {
11937 HANDLE_EXCEPTION();
11938 }
11939 }
11940 /* call static method */
11941 obj = (zend_object*)called_scope;
11942 call_info = ZEND_CALL_NESTED_FUNCTION;
11943 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
11944 if (IS_CONST == IS_CV) {
11945 GC_ADDREF(obj); /* For $this pointer */
11946 }
11947 /* CV may be changed indirectly (e.g. when it's a reference) */
11948 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
11949 }
11950
11951 call = zend_vm_stack_push_call_frame(call_info,
11952 fbc, opline->extended_value, obj);
11953 call->prev_execute_data = EX(call);
11954 EX(call) = call;
11955
11956 ZEND_VM_NEXT_OPCODE();
11957 }
11958
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11959 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11960 {
11961 USE_OPLINE
11962 zval *function_name;
11963 zend_class_entry *ce;
11964 uint32_t call_info;
11965 zend_function *fbc;
11966 zend_execute_data *call;
11967
11968 SAVE_OPLINE();
11969
11970 if (IS_CONST == IS_CONST) {
11971 /* no function found. try a static method in class */
11972 ce = CACHED_PTR(opline->result.num);
11973 if (UNEXPECTED(ce == NULL)) {
11974 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);
11975 if (UNEXPECTED(ce == NULL)) {
11976
11977 HANDLE_EXCEPTION();
11978 }
11979 if (IS_CV != IS_CONST) {
11980 CACHE_PTR(opline->result.num, ce);
11981 }
11982 }
11983 } else if (IS_CONST == IS_UNUSED) {
11984 ce = zend_fetch_class(NULL, opline->op1.num);
11985 if (UNEXPECTED(ce == NULL)) {
11986
11987 HANDLE_EXCEPTION();
11988 }
11989 } else {
11990 ce = Z_CE_P(EX_VAR(opline->op1.var));
11991 }
11992
11993 if (IS_CONST == IS_CONST &&
11994 IS_CV == IS_CONST &&
11995 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
11996 /* nothing to do */
11997 } else if (IS_CONST != IS_CONST &&
11998 IS_CV == IS_CONST &&
11999 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
12000 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
12001 } else if (IS_CV != IS_UNUSED) {
12002 function_name = EX_VAR(opline->op2.var);
12003 if (IS_CV != IS_CONST) {
12004 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12005 do {
12006 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
12007 function_name = Z_REFVAL_P(function_name);
12008 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
12009 break;
12010 }
12011 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
12012 ZVAL_UNDEFINED_OP2();
12013 if (UNEXPECTED(EG(exception) != NULL)) {
12014 HANDLE_EXCEPTION();
12015 }
12016 }
12017 zend_throw_error(NULL, "Method name must be a string");
12018
12019 HANDLE_EXCEPTION();
12020 } while (0);
12021 }
12022 }
12023
12024 if (ce->get_static_method) {
12025 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
12026 } else {
12027 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
12028 }
12029 if (UNEXPECTED(fbc == NULL)) {
12030 if (EXPECTED(!EG(exception))) {
12031 zend_undefined_method(ce, Z_STR_P(function_name));
12032 }
12033
12034 HANDLE_EXCEPTION();
12035 }
12036 if (IS_CV == IS_CONST &&
12037 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
12038 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
12039 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
12040 }
12041 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12042 init_func_run_time_cache(&fbc->op_array);
12043 }
12044 if (IS_CV != IS_CONST) {
12045
12046 }
12047 } else {
12048 if (UNEXPECTED(ce->constructor == NULL)) {
12049 zend_throw_error(NULL, "Cannot call constructor");
12050 HANDLE_EXCEPTION();
12051 }
12052 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
12053 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
12054 HANDLE_EXCEPTION();
12055 }
12056 fbc = ce->constructor;
12057 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12058 init_func_run_time_cache(&fbc->op_array);
12059 }
12060 }
12061
12062 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
12063 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
12064 ce = (zend_class_entry*)Z_OBJ(EX(This));
12065 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
12066 } else {
12067 zend_non_static_method_call(fbc);
12068 HANDLE_EXCEPTION();
12069 }
12070 } else {
12071 /* previous opcode is ZEND_FETCH_CLASS */
12072 if (IS_CONST == IS_UNUSED
12073 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
12074 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
12075 if (Z_TYPE(EX(This)) == IS_OBJECT) {
12076 ce = Z_OBJCE(EX(This));
12077 } else {
12078 ce = Z_CE(EX(This));
12079 }
12080 }
12081 call_info = ZEND_CALL_NESTED_FUNCTION;
12082 }
12083
12084 call = zend_vm_stack_push_call_frame(call_info,
12085 fbc, opline->extended_value, ce);
12086 call->prev_execute_data = EX(call);
12087 EX(call) = call;
12088
12089 ZEND_VM_NEXT_OPCODE();
12090 }
12091
ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12092 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12093 {
12094 USE_OPLINE
12095 zval *function_name;
12096 zend_fcall_info_cache fcc;
12097 char *error = NULL;
12098 zend_function *func;
12099 void *object_or_called_scope;
12100 zend_execute_data *call;
12101 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
12102
12103 SAVE_OPLINE();
12104 function_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12105 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
12106 ZEND_ASSERT(!error);
12107 func = fcc.function_handler;
12108 object_or_called_scope = fcc.called_scope;
12109 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
12110 /* Delay closure destruction until its invocation */
12111 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
12112 call_info |= ZEND_CALL_CLOSURE;
12113 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
12114 call_info |= ZEND_CALL_FAKE_CLOSURE;
12115 }
12116 if (fcc.object) {
12117 object_or_called_scope = fcc.object;
12118 call_info |= ZEND_CALL_HAS_THIS;
12119 }
12120 } else if (fcc.object) {
12121 GC_ADDREF(fcc.object); /* For $this pointer */
12122 object_or_called_scope = fcc.object;
12123 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
12124 }
12125
12126 if ((IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
12127 if (call_info & ZEND_CALL_CLOSURE) {
12128 zend_object_release(ZEND_CLOSURE_OBJECT(func));
12129 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
12130 zend_object_release(fcc.object);
12131 }
12132 HANDLE_EXCEPTION();
12133 }
12134
12135 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
12136 init_func_run_time_cache(&func->op_array);
12137 }
12138 } else {
12139 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
12140 efree(error);
12141
12142 HANDLE_EXCEPTION();
12143 }
12144
12145 call = zend_vm_stack_push_call_frame(call_info,
12146 func, opline->extended_value, object_or_called_scope);
12147 call->prev_execute_data = EX(call);
12148 EX(call) = call;
12149
12150 ZEND_VM_NEXT_OPCODE();
12151 }
12152
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12153 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12154 {
12155 USE_OPLINE
12156 zval *expr_ptr, new_expr;
12157
12158 SAVE_OPLINE();
12159 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
12160 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
12161 expr_ptr = zend_get_bad_ptr();
12162 if (Z_ISREF_P(expr_ptr)) {
12163 Z_ADDREF_P(expr_ptr);
12164 } else {
12165 ZVAL_MAKE_REF_EX(expr_ptr, 2);
12166 }
12167
12168 } else {
12169 expr_ptr = RT_CONSTANT(opline, opline->op1);
12170 if (IS_CONST == IS_TMP_VAR) {
12171 /* pass */
12172 } else if (IS_CONST == IS_CONST) {
12173 Z_TRY_ADDREF_P(expr_ptr);
12174 } else if (IS_CONST == IS_CV) {
12175 ZVAL_DEREF(expr_ptr);
12176 Z_TRY_ADDREF_P(expr_ptr);
12177 } else /* if (IS_CONST == IS_VAR) */ {
12178 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
12179 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
12180
12181 expr_ptr = Z_REFVAL_P(expr_ptr);
12182 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
12183 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
12184 expr_ptr = &new_expr;
12185 efree_size(ref, sizeof(zend_reference));
12186 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
12187 Z_ADDREF_P(expr_ptr);
12188 }
12189 }
12190 }
12191 }
12192
12193 if (IS_CV != IS_UNUSED) {
12194 zval *offset = EX_VAR(opline->op2.var);
12195 zend_string *str;
12196 zend_ulong hval;
12197
12198 add_again:
12199 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12200 str = Z_STR_P(offset);
12201 if (IS_CV != IS_CONST) {
12202 if (ZEND_HANDLE_NUMERIC(str, hval)) {
12203 goto num_index;
12204 }
12205 }
12206 str_index:
12207 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
12208 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12209 hval = Z_LVAL_P(offset);
12210 num_index:
12211 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
12212 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
12213 offset = Z_REFVAL_P(offset);
12214 goto add_again;
12215 } else if (Z_TYPE_P(offset) == IS_NULL) {
12216 str = ZSTR_EMPTY_ALLOC();
12217 goto str_index;
12218 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
12219 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
12220 goto num_index;
12221 } else if (Z_TYPE_P(offset) == IS_FALSE) {
12222 hval = 0;
12223 goto num_index;
12224 } else if (Z_TYPE_P(offset) == IS_TRUE) {
12225 hval = 1;
12226 goto num_index;
12227 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
12228 zend_use_resource_as_offset(offset);
12229 hval = Z_RES_HANDLE_P(offset);
12230 goto num_index;
12231 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
12232 ZVAL_UNDEFINED_OP2();
12233 str = ZSTR_EMPTY_ALLOC();
12234 goto str_index;
12235 } else {
12236 zend_illegal_array_offset_access(offset);
12237 zval_ptr_dtor_nogc(expr_ptr);
12238 }
12239
12240 } else {
12241 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
12242 zend_cannot_add_element();
12243 zval_ptr_dtor_nogc(expr_ptr);
12244 }
12245 }
12246 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12247 }
12248
ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12249 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12250 {
12251 zval *array;
12252 uint32_t size;
12253 USE_OPLINE
12254
12255 array = EX_VAR(opline->result.var);
12256 if (IS_CONST != IS_UNUSED) {
12257 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
12258 ZVAL_ARR(array, zend_new_array(size));
12259 /* Explicitly initialize array as not-packed if flag is set */
12260 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
12261 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
12262 }
12263 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12264 } else {
12265 ZVAL_ARR(array, zend_new_array(0));
12266 ZEND_VM_NEXT_OPCODE();
12267 }
12268 }
12269
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12270 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12271 {
12272 USE_OPLINE
12273 zval *container;
12274 bool result;
12275 zend_ulong hval;
12276 zval *offset;
12277
12278 SAVE_OPLINE();
12279 container = RT_CONSTANT(opline, opline->op1);
12280 offset = EX_VAR(opline->op2.var);
12281
12282 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12283 HashTable *ht;
12284 zval *value;
12285 zend_string *str;
12286
12287 isset_dim_obj_array:
12288 ht = Z_ARRVAL_P(container);
12289 isset_again:
12290 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12291 str = Z_STR_P(offset);
12292 if (IS_CV != IS_CONST) {
12293 if (ZEND_HANDLE_NUMERIC(str, hval)) {
12294 goto num_index_prop;
12295 }
12296 }
12297 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
12298 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12299 hval = Z_LVAL_P(offset);
12300 num_index_prop:
12301 value = zend_hash_index_find(ht, hval);
12302 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
12303 offset = Z_REFVAL_P(offset);
12304 goto isset_again;
12305 } else {
12306 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
12307 if (UNEXPECTED(EG(exception))) {
12308 result = 0;
12309 goto isset_dim_obj_exit;
12310 }
12311 }
12312
12313 if (!(opline->extended_value & ZEND_ISEMPTY)) {
12314 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
12315 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
12316 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
12317
12318 if (IS_CONST & (IS_CONST|IS_CV)) {
12319 /* avoid exception check */
12320
12321 ZEND_VM_SMART_BRANCH(result, 0);
12322 }
12323 } else {
12324 result = (value == NULL || !i_zend_is_true(value));
12325 }
12326 goto isset_dim_obj_exit;
12327 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
12328 container = Z_REFVAL_P(container);
12329 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12330 goto isset_dim_obj_array;
12331 }
12332 }
12333
12334 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
12335 offset++;
12336 }
12337 if (!(opline->extended_value & ZEND_ISEMPTY)) {
12338 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
12339 } else {
12340 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
12341 }
12342
12343 isset_dim_obj_exit:
12344
12345
12346 ZEND_VM_SMART_BRANCH(result, 1);
12347 }
12348
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12349 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12350 {
12351 USE_OPLINE
12352 zval *container;
12353 int result;
12354 zval *offset;
12355 zend_string *name, *tmp_name;
12356
12357 SAVE_OPLINE();
12358 container = RT_CONSTANT(opline, opline->op1);
12359 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12360
12361 if (IS_CONST == IS_CONST ||
12362 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
12363 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
12364 container = Z_REFVAL_P(container);
12365 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
12366 result = (opline->extended_value & ZEND_ISEMPTY);
12367 goto isset_object_finish;
12368 }
12369 } else {
12370 result = (opline->extended_value & ZEND_ISEMPTY);
12371 goto isset_object_finish;
12372 }
12373 }
12374
12375 if (IS_CV == IS_CONST) {
12376 name = Z_STR_P(offset);
12377 } else {
12378 name = zval_try_get_tmp_string(offset, &tmp_name);
12379 if (UNEXPECTED(!name)) {
12380 result = 0;
12381 goto isset_object_finish;
12382 }
12383 }
12384
12385 result =
12386 (opline->extended_value & ZEND_ISEMPTY) ^
12387 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));
12388
12389 if (IS_CV != IS_CONST) {
12390 zend_tmp_string_release(tmp_name);
12391 }
12392
12393 isset_object_finish:
12394
12395
12396 ZEND_VM_SMART_BRANCH(result, 1);
12397 }
12398
ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12399 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12400 {
12401 USE_OPLINE
12402
12403 zval *key, *subject;
12404 HashTable *ht;
12405 bool result;
12406
12407 SAVE_OPLINE();
12408
12409 key = RT_CONSTANT(opline, opline->op1);
12410 subject = EX_VAR(opline->op2.var);
12411
12412 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12413 array_key_exists_array:
12414 ht = Z_ARRVAL_P(subject);
12415 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
12416 } else {
12417 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
12418 subject = Z_REFVAL_P(subject);
12419 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12420 goto array_key_exists_array;
12421 }
12422 }
12423 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
12424 result = 0;
12425 }
12426
12427
12428 ZEND_VM_SMART_BRANCH(result, 1);
12429 }
12430
12431 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12432 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12433 {
12434 USE_OPLINE
12435
12436 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
12437
12438 SAVE_OPLINE();
12439 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
12440 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12441 }
12442
12443 /* Destroy the previously yielded value */
12444 zval_ptr_dtor(&generator->value);
12445
12446 /* Destroy the previously yielded key */
12447 zval_ptr_dtor(&generator->key);
12448
12449 /* Set the new yielded value */
12450 if (IS_CONST != IS_UNUSED) {
12451 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
12452 /* Constants and temporary variables aren't yieldable by reference,
12453 * but we still allow them with a notice. */
12454 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
12455 zval *value;
12456
12457 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12458
12459 value = RT_CONSTANT(opline, opline->op1);
12460 ZVAL_COPY_VALUE(&generator->value, value);
12461 if (IS_CONST == IS_CONST) {
12462 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12463 Z_ADDREF(generator->value);
12464 }
12465 }
12466 } else {
12467 zval *value_ptr = zend_get_bad_ptr();
12468
12469 /* If a function call result is yielded and the function did
12470 * not return by reference we throw a notice. */
12471 do {
12472 if (IS_CONST == IS_VAR) {
12473 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
12474 if (opline->extended_value == ZEND_RETURNS_FUNCTION
12475 && !Z_ISREF_P(value_ptr)) {
12476 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12477 ZVAL_COPY(&generator->value, value_ptr);
12478 break;
12479 }
12480 }
12481 if (Z_ISREF_P(value_ptr)) {
12482 Z_ADDREF_P(value_ptr);
12483 } else {
12484 ZVAL_MAKE_REF_EX(value_ptr, 2);
12485 }
12486 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
12487 } while (0);
12488
12489 }
12490 } else {
12491 zval *value = RT_CONSTANT(opline, opline->op1);
12492
12493 /* Consts, temporary variables and references need copying */
12494 if (IS_CONST == IS_CONST) {
12495 ZVAL_COPY_VALUE(&generator->value, value);
12496 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12497 Z_ADDREF(generator->value);
12498 }
12499 } else if (IS_CONST == IS_TMP_VAR) {
12500 ZVAL_COPY_VALUE(&generator->value, value);
12501 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
12502 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
12503
12504 } else {
12505 ZVAL_COPY_VALUE(&generator->value, value);
12506 if (IS_CONST == IS_CV) {
12507 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
12508 }
12509 }
12510 }
12511 } else {
12512 /* If no value was specified yield null */
12513 ZVAL_NULL(&generator->value);
12514 }
12515
12516 /* Set the new yielded key */
12517 if (IS_CV != IS_UNUSED) {
12518 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12519 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
12520 key = Z_REFVAL_P(key);
12521 }
12522 ZVAL_COPY(&generator->key, key);
12523
12524 if (Z_TYPE(generator->key) == IS_LONG
12525 && Z_LVAL(generator->key) > generator->largest_used_integer_key
12526 ) {
12527 generator->largest_used_integer_key = Z_LVAL(generator->key);
12528 }
12529 } else {
12530 /* If no key was specified we use auto-increment keys */
12531 generator->largest_used_integer_key++;
12532 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
12533 }
12534
12535 if (RETURN_VALUE_USED(opline)) {
12536 /* If the return value of yield is used set the send
12537 * target and initialize it to NULL */
12538 generator->send_target = EX_VAR(opline->result.var);
12539 ZVAL_NULL(generator->send_target);
12540 } else {
12541 generator->send_target = NULL;
12542 }
12543
12544 /* We increment to the next op, so we are at the correct position when the
12545 * generator is resumed. */
12546 ZEND_VM_INC_OPCODE();
12547
12548 /* The GOTO VM uses a local opline variable. We need to set the opline
12549 * variable in execute_data so we don't resume at an old position. */
12550 SAVE_OPLINE();
12551
12552 ZEND_VM_RETURN();
12553 }
12554
ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12555 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12556 {
12557 USE_OPLINE
12558 zval *op1;
12559
12560 op1 = EX_VAR(opline->op1.var);
12561 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12562 ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
12563 ZEND_VM_NEXT_OPCODE();
12564 }
12565
12566 ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(op1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12567 }
12568
ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12569 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12570 {
12571 USE_OPLINE
12572 zval *value;
12573
12574 value = EX_VAR(opline->op1.var);
12575 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
12576 ZEND_VM_NEXT_OPCODE();
12577 }
12578
ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12579 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12580 {
12581 USE_OPLINE
12582 zval *value;
12583
12584 value = EX_VAR(opline->op1.var);
12585 ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
12586 ZEND_VM_NEXT_OPCODE();
12587 }
12588
ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12589 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12590 {
12591 USE_OPLINE
12592 zval *value;
12593
12594 value = EX_VAR(opline->op1.var);
12595 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
12596 ZEND_VM_NEXT_OPCODE();
12597 }
12598
ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12599 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12600 {
12601 USE_OPLINE
12602 zval *op1, *op2, *result;
12603 double d1, d2;
12604
12605 op1 = EX_VAR(opline->op1.var);
12606 op2 = RT_CONSTANT(opline, opline->op2);
12607 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12608 /* pass */
12609 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12610 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12611 result = EX_VAR(opline->result.var);
12612 fast_long_add_function(result, op1, op2);
12613 ZEND_VM_NEXT_OPCODE();
12614 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12615 d1 = (double)Z_LVAL_P(op1);
12616 d2 = Z_DVAL_P(op2);
12617 goto add_double;
12618 }
12619 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12620 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12621 d1 = Z_DVAL_P(op1);
12622 d2 = Z_DVAL_P(op2);
12623 add_double:
12624 result = EX_VAR(opline->result.var);
12625 ZVAL_DOUBLE(result, d1 + d2);
12626 ZEND_VM_NEXT_OPCODE();
12627 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12628 d1 = Z_DVAL_P(op1);
12629 d2 = (double)Z_LVAL_P(op2);
12630 goto add_double;
12631 }
12632 }
12633
12634 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12635 }
12636
ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12637 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12638 {
12639 USE_OPLINE
12640 zval *op1, *op2, *result;
12641 double d1, d2;
12642
12643 op1 = EX_VAR(opline->op1.var);
12644 op2 = RT_CONSTANT(opline, opline->op2);
12645 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12646 /* pass */
12647 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12648 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12649 result = EX_VAR(opline->result.var);
12650 fast_long_sub_function(result, op1, op2);
12651 ZEND_VM_NEXT_OPCODE();
12652 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12653 d1 = (double)Z_LVAL_P(op1);
12654 d2 = Z_DVAL_P(op2);
12655 goto sub_double;
12656 }
12657 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12658 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12659 d1 = Z_DVAL_P(op1);
12660 d2 = Z_DVAL_P(op2);
12661 sub_double:
12662 result = EX_VAR(opline->result.var);
12663 ZVAL_DOUBLE(result, d1 - d2);
12664 ZEND_VM_NEXT_OPCODE();
12665 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12666 d1 = Z_DVAL_P(op1);
12667 d2 = (double)Z_LVAL_P(op2);
12668 goto sub_double;
12669 }
12670 }
12671
12672 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12673 }
12674
ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12675 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12676 {
12677 USE_OPLINE
12678 zval *op1, *op2, *result;
12679 double d1, d2;
12680
12681 op1 = EX_VAR(opline->op1.var);
12682 op2 = RT_CONSTANT(opline, opline->op2);
12683 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12684 /* pass */
12685 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12686 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12687 zend_long overflow;
12688
12689 result = EX_VAR(opline->result.var);
12690 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
12691 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
12692 ZEND_VM_NEXT_OPCODE();
12693 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12694 d1 = (double)Z_LVAL_P(op1);
12695 d2 = Z_DVAL_P(op2);
12696 goto mul_double;
12697 }
12698 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12699 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12700 d1 = Z_DVAL_P(op1);
12701 d2 = Z_DVAL_P(op2);
12702 mul_double:
12703 result = EX_VAR(opline->result.var);
12704 ZVAL_DOUBLE(result, d1 * d2);
12705 ZEND_VM_NEXT_OPCODE();
12706 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12707 d1 = Z_DVAL_P(op1);
12708 d2 = (double)Z_LVAL_P(op2);
12709 goto mul_double;
12710 }
12711 }
12712
12713 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12714 }
12715
ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12716 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12717 {
12718 USE_OPLINE
12719 zval *op1, *op2, *result;
12720
12721 op1 = EX_VAR(opline->op1.var);
12722 op2 = RT_CONSTANT(opline, opline->op2);
12723 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12724 /* pass */
12725 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12726 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12727 result = EX_VAR(opline->result.var);
12728 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
12729 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12730 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
12731 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
12732 ZVAL_LONG(result, 0);
12733 } else {
12734 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
12735 }
12736 ZEND_VM_NEXT_OPCODE();
12737 }
12738 }
12739
12740 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12741 }
12742
ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12743 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12744 {
12745 USE_OPLINE
12746 zval *op1, *op2;
12747
12748 op1 = EX_VAR(opline->op1.var);
12749 op2 = RT_CONSTANT(opline, opline->op2);
12750 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12751 /* pass */
12752 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
12753 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
12754 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
12755 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
12756 ZVAL_LONG(EX_VAR(opline->result.var),
12757 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
12758 ZEND_VM_NEXT_OPCODE();
12759 }
12760
12761 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12762 }
12763
ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12764 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12765 {
12766 USE_OPLINE
12767 zval *op1, *op2;
12768
12769 op1 = EX_VAR(opline->op1.var);
12770 op2 = RT_CONSTANT(opline, opline->op2);
12771 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12772 /* pass */
12773 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
12774 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
12775 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
12776 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
12777 ZEND_VM_NEXT_OPCODE();
12778 }
12779
12780 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12781 }
12782
ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12783 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12784 {
12785 USE_OPLINE
12786 zval *op1, *op2;
12787 double d1, d2;
12788
12789 op1 = EX_VAR(opline->op1.var);
12790 op2 = RT_CONSTANT(opline, opline->op2);
12791 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12792 /* pass */
12793 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12794 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12795 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
12796 is_smaller_true:
12797 ZEND_VM_SMART_BRANCH_TRUE_NONE();
12798 } else {
12799 is_smaller_false:
12800 ZEND_VM_SMART_BRANCH_FALSE_NONE();
12801 }
12802 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12803 d1 = (double)Z_LVAL_P(op1);
12804 d2 = Z_DVAL_P(op2);
12805 goto is_smaller_double;
12806 }
12807 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12808 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12809 d1 = Z_DVAL_P(op1);
12810 d2 = Z_DVAL_P(op2);
12811 is_smaller_double:
12812 if (d1 < d2) {
12813 goto is_smaller_true;
12814 } else {
12815 goto is_smaller_false;
12816 }
12817 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12818 d1 = Z_DVAL_P(op1);
12819 d2 = (double)Z_LVAL_P(op2);
12820 goto is_smaller_double;
12821 }
12822 }
12823 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12824 }
12825
ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12826 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12827 {
12828 USE_OPLINE
12829 zval *op1, *op2;
12830 double d1, d2;
12831
12832 op1 = EX_VAR(opline->op1.var);
12833 op2 = RT_CONSTANT(opline, opline->op2);
12834 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12835 /* pass */
12836 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12837 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12838 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
12839 is_smaller_true:
12840 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
12841 } else {
12842 is_smaller_false:
12843 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
12844 }
12845 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12846 d1 = (double)Z_LVAL_P(op1);
12847 d2 = Z_DVAL_P(op2);
12848 goto is_smaller_double;
12849 }
12850 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12851 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12852 d1 = Z_DVAL_P(op1);
12853 d2 = Z_DVAL_P(op2);
12854 is_smaller_double:
12855 if (d1 < d2) {
12856 goto is_smaller_true;
12857 } else {
12858 goto is_smaller_false;
12859 }
12860 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12861 d1 = Z_DVAL_P(op1);
12862 d2 = (double)Z_LVAL_P(op2);
12863 goto is_smaller_double;
12864 }
12865 }
12866 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12867 }
12868
ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12869 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12870 {
12871 USE_OPLINE
12872 zval *op1, *op2;
12873 double d1, d2;
12874
12875 op1 = EX_VAR(opline->op1.var);
12876 op2 = RT_CONSTANT(opline, opline->op2);
12877 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12878 /* pass */
12879 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12880 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12881 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
12882 is_smaller_true:
12883 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
12884 } else {
12885 is_smaller_false:
12886 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
12887 }
12888 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12889 d1 = (double)Z_LVAL_P(op1);
12890 d2 = Z_DVAL_P(op2);
12891 goto is_smaller_double;
12892 }
12893 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12894 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12895 d1 = Z_DVAL_P(op1);
12896 d2 = Z_DVAL_P(op2);
12897 is_smaller_double:
12898 if (d1 < d2) {
12899 goto is_smaller_true;
12900 } else {
12901 goto is_smaller_false;
12902 }
12903 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12904 d1 = Z_DVAL_P(op1);
12905 d2 = (double)Z_LVAL_P(op2);
12906 goto is_smaller_double;
12907 }
12908 }
12909 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12910 }
12911
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12912 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12913 {
12914 USE_OPLINE
12915 zval *op1, *op2;
12916 double d1, d2;
12917
12918 op1 = EX_VAR(opline->op1.var);
12919 op2 = RT_CONSTANT(opline, opline->op2);
12920 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12921 /* pass */
12922 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12923 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12924 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
12925 is_smaller_or_equal_true:
12926 ZEND_VM_SMART_BRANCH_TRUE_NONE();
12927 ZVAL_TRUE(EX_VAR(opline->result.var));
12928 ZEND_VM_NEXT_OPCODE();
12929 } else {
12930 is_smaller_or_equal_false:
12931 ZEND_VM_SMART_BRANCH_FALSE_NONE();
12932 ZVAL_FALSE(EX_VAR(opline->result.var));
12933 ZEND_VM_NEXT_OPCODE();
12934 }
12935 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12936 d1 = (double)Z_LVAL_P(op1);
12937 d2 = Z_DVAL_P(op2);
12938 goto is_smaller_or_equal_double;
12939 }
12940 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12941 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12942 d1 = Z_DVAL_P(op1);
12943 d2 = Z_DVAL_P(op2);
12944 is_smaller_or_equal_double:
12945 if (d1 <= d2) {
12946 goto is_smaller_or_equal_true;
12947 } else {
12948 goto is_smaller_or_equal_false;
12949 }
12950 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12951 d1 = Z_DVAL_P(op1);
12952 d2 = (double)Z_LVAL_P(op2);
12953 goto is_smaller_or_equal_double;
12954 }
12955 }
12956 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12957 }
12958
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12959 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12960 {
12961 USE_OPLINE
12962 zval *op1, *op2;
12963 double d1, d2;
12964
12965 op1 = EX_VAR(opline->op1.var);
12966 op2 = RT_CONSTANT(opline, opline->op2);
12967 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12968 /* pass */
12969 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12970 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12971 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
12972 is_smaller_or_equal_true:
12973 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
12974 ZVAL_TRUE(EX_VAR(opline->result.var));
12975 ZEND_VM_NEXT_OPCODE();
12976 } else {
12977 is_smaller_or_equal_false:
12978 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
12979 ZVAL_FALSE(EX_VAR(opline->result.var));
12980 ZEND_VM_NEXT_OPCODE();
12981 }
12982 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12983 d1 = (double)Z_LVAL_P(op1);
12984 d2 = Z_DVAL_P(op2);
12985 goto is_smaller_or_equal_double;
12986 }
12987 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12988 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12989 d1 = Z_DVAL_P(op1);
12990 d2 = Z_DVAL_P(op2);
12991 is_smaller_or_equal_double:
12992 if (d1 <= d2) {
12993 goto is_smaller_or_equal_true;
12994 } else {
12995 goto is_smaller_or_equal_false;
12996 }
12997 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12998 d1 = Z_DVAL_P(op1);
12999 d2 = (double)Z_LVAL_P(op2);
13000 goto is_smaller_or_equal_double;
13001 }
13002 }
13003 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13004 }
13005
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13006 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13007 {
13008 USE_OPLINE
13009 zval *op1, *op2;
13010 double d1, d2;
13011
13012 op1 = EX_VAR(opline->op1.var);
13013 op2 = RT_CONSTANT(opline, opline->op2);
13014 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13015 /* pass */
13016 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13017 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13018 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13019 is_smaller_or_equal_true:
13020 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13021 ZVAL_TRUE(EX_VAR(opline->result.var));
13022 ZEND_VM_NEXT_OPCODE();
13023 } else {
13024 is_smaller_or_equal_false:
13025 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13026 ZVAL_FALSE(EX_VAR(opline->result.var));
13027 ZEND_VM_NEXT_OPCODE();
13028 }
13029 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13030 d1 = (double)Z_LVAL_P(op1);
13031 d2 = Z_DVAL_P(op2);
13032 goto is_smaller_or_equal_double;
13033 }
13034 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13035 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13036 d1 = Z_DVAL_P(op1);
13037 d2 = Z_DVAL_P(op2);
13038 is_smaller_or_equal_double:
13039 if (d1 <= d2) {
13040 goto is_smaller_or_equal_true;
13041 } else {
13042 goto is_smaller_or_equal_false;
13043 }
13044 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13045 d1 = Z_DVAL_P(op1);
13046 d2 = (double)Z_LVAL_P(op2);
13047 goto is_smaller_or_equal_double;
13048 }
13049 }
13050 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13051 }
13052
ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13053 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_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_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13069 }
13070
ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13071 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_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_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13087 }
13088
ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13089 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13090 {
13091 USE_OPLINE
13092 zval *op1, *op2;
13093
13094 op1 = EX_VAR(opline->op1.var);
13095 op2 = RT_CONSTANT(opline, opline->op2);
13096 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13097 /* pass */
13098 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13099 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13100 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
13101 ZEND_VM_NEXT_OPCODE();
13102 }
13103
13104 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13105 }
13106
ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13107 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13108 {
13109 USE_OPLINE
13110 zval *container;
13111
13112 SAVE_OPLINE();
13113 container = EX_VAR(opline->op1.var);
13114 zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
13115
13116 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
13117 }
13118
ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13119 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13120 {
13121 USE_OPLINE
13122 zval *op, *jump_zv;
13123 HashTable *jumptable;
13124
13125 op = EX_VAR(opline->op1.var);
13126
13127 if (Z_TYPE_P(op) != IS_LONG) {
13128 ZVAL_DEREF(op);
13129 if (Z_TYPE_P(op) != IS_LONG) {
13130 /* Wrong type, fall back to ZEND_CASE chain */
13131 ZEND_VM_NEXT_OPCODE();
13132 }
13133 }
13134
13135 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13136 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13137 if (jump_zv != NULL) {
13138 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13139 ZEND_VM_CONTINUE();
13140 } else {
13141 /* default */
13142 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13143 ZEND_VM_CONTINUE();
13144 }
13145 }
13146
ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13147 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13148 {
13149 USE_OPLINE
13150 zval *op, *jump_zv;
13151 HashTable *jumptable;
13152
13153 op = EX_VAR(opline->op1.var);
13154
13155 if (Z_TYPE_P(op) != IS_STRING) {
13156 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13157 /* Wrong type, fall back to ZEND_CASE chain */
13158 ZEND_VM_NEXT_OPCODE();
13159 } else {
13160 ZVAL_DEREF(op);
13161 if (Z_TYPE_P(op) != IS_STRING) {
13162 /* Wrong type, fall back to ZEND_CASE chain */
13163 ZEND_VM_NEXT_OPCODE();
13164 }
13165 }
13166 }
13167
13168 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13169 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13170 if (jump_zv != NULL) {
13171 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13172 ZEND_VM_CONTINUE();
13173 } else {
13174 /* default */
13175 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13176 ZEND_VM_CONTINUE();
13177 }
13178 }
13179
ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13180 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13181 {
13182 USE_OPLINE
13183 zval *op, *jump_zv;
13184 HashTable *jumptable;
13185
13186 op = EX_VAR(opline->op1.var);
13187 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13188
13189 match_try_again:
13190 if (Z_TYPE_P(op) == IS_LONG) {
13191 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13192 } else if (Z_TYPE_P(op) == IS_STRING) {
13193 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13194 } else if (Z_TYPE_P(op) == IS_REFERENCE) {
13195 op = Z_REFVAL_P(op);
13196 goto match_try_again;
13197 } else {
13198 if (UNEXPECTED(((IS_TMP_VAR|IS_VAR|IS_CV) & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
13199 SAVE_OPLINE();
13200 op = ZVAL_UNDEFINED_OP1();
13201 if (UNEXPECTED(EG(exception))) {
13202 HANDLE_EXCEPTION();
13203 }
13204 goto match_try_again;
13205 }
13206
13207 goto default_branch;
13208 }
13209
13210 if (jump_zv != NULL) {
13211 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13212 ZEND_VM_CONTINUE();
13213 } else {
13214 default_branch:
13215 /* default */
13216 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13217 ZEND_VM_CONTINUE();
13218 }
13219 }
13220
ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13221 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13222 {
13223 USE_OPLINE
13224 zval *op1, *op2, *result;
13225
13226 op1 = EX_VAR(opline->op1.var);
13227 op2 = RT_CONSTANT(opline, opline->op2);
13228 result = EX_VAR(opline->result.var);
13229 ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
13230 ZEND_VM_NEXT_OPCODE();
13231 }
13232
ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13233 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13234 {
13235 USE_OPLINE
13236 zval *op1, *op2, *result;
13237
13238 op1 = EX_VAR(opline->op1.var);
13239 op2 = RT_CONSTANT(opline, opline->op2);
13240 result = EX_VAR(opline->result.var);
13241 fast_long_add_function(result, op1, op2);
13242 ZEND_VM_NEXT_OPCODE();
13243 }
13244
ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13245 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13246 {
13247 USE_OPLINE
13248 zval *op1, *op2, *result;
13249
13250 op1 = EX_VAR(opline->op1.var);
13251 op2 = RT_CONSTANT(opline, opline->op2);
13252 result = EX_VAR(opline->result.var);
13253 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
13254 ZEND_VM_NEXT_OPCODE();
13255 }
13256
ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13257 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13258 {
13259 USE_OPLINE
13260 zval *op1, *op2, *result;
13261
13262 op1 = EX_VAR(opline->op1.var);
13263 op2 = RT_CONSTANT(opline, opline->op2);
13264 result = EX_VAR(opline->result.var);
13265 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
13266 ZEND_VM_NEXT_OPCODE();
13267 }
13268
ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13269 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13270 {
13271 USE_OPLINE
13272 zval *op1, *op2, *result;
13273
13274 op1 = EX_VAR(opline->op1.var);
13275 op2 = RT_CONSTANT(opline, opline->op2);
13276 result = EX_VAR(opline->result.var);
13277 fast_long_sub_function(result, op1, op2);
13278 ZEND_VM_NEXT_OPCODE();
13279 }
13280
ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13281 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13282 {
13283 USE_OPLINE
13284 zval *op1, *op2, *result;
13285
13286 op1 = EX_VAR(opline->op1.var);
13287 op2 = RT_CONSTANT(opline, opline->op2);
13288 result = EX_VAR(opline->result.var);
13289 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
13290 ZEND_VM_NEXT_OPCODE();
13291 }
13292
ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13293 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13294 {
13295 USE_OPLINE
13296 zval *op1, *op2, *result;
13297
13298 op1 = EX_VAR(opline->op1.var);
13299 op2 = RT_CONSTANT(opline, opline->op2);
13300 result = EX_VAR(opline->result.var);
13301 ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
13302 ZEND_VM_NEXT_OPCODE();
13303 }
13304
ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13305 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13306 {
13307 USE_OPLINE
13308 zval *op1, *op2, *result;
13309 zend_long overflow;
13310
13311 op1 = EX_VAR(opline->op1.var);
13312 op2 = RT_CONSTANT(opline, opline->op2);
13313 result = EX_VAR(opline->result.var);
13314 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13315 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13316 ZEND_VM_NEXT_OPCODE();
13317 }
13318
ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13319 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13320 {
13321 USE_OPLINE
13322 zval *op1, *op2, *result;
13323
13324 op1 = EX_VAR(opline->op1.var);
13325 op2 = RT_CONSTANT(opline, opline->op2);
13326 result = EX_VAR(opline->result.var);
13327 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
13328 ZEND_VM_NEXT_OPCODE();
13329 }
13330
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13331 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13332 {
13333 USE_OPLINE
13334 zval *op1, *op2;
13335 bool result;
13336
13337 op1 = EX_VAR(opline->op1.var);
13338 op2 = RT_CONSTANT(opline, opline->op2);
13339 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13340 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13341 }
13342
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13343 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13344 {
13345 USE_OPLINE
13346 zval *op1, *op2;
13347 bool result;
13348
13349 op1 = EX_VAR(opline->op1.var);
13350 op2 = RT_CONSTANT(opline, opline->op2);
13351 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13352 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13353 }
13354
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13355 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13356 {
13357 USE_OPLINE
13358 zval *op1, *op2;
13359 bool result;
13360
13361 op1 = EX_VAR(opline->op1.var);
13362 op2 = RT_CONSTANT(opline, opline->op2);
13363 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13364 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13365 }
13366
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13367 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13368 {
13369 USE_OPLINE
13370 zval *op1, *op2;
13371 bool result;
13372
13373 op1 = EX_VAR(opline->op1.var);
13374 op2 = RT_CONSTANT(opline, opline->op2);
13375 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13376 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13377 }
13378
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13379 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13380 {
13381 USE_OPLINE
13382 zval *op1, *op2;
13383 bool result;
13384
13385 op1 = EX_VAR(opline->op1.var);
13386 op2 = RT_CONSTANT(opline, opline->op2);
13387 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13388 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13389 }
13390
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13391 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13392 {
13393 USE_OPLINE
13394 zval *op1, *op2;
13395 bool result;
13396
13397 op1 = EX_VAR(opline->op1.var);
13398 op2 = RT_CONSTANT(opline, opline->op2);
13399 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13400 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13401 }
13402
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13403 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13404 {
13405 USE_OPLINE
13406 zval *op1, *op2;
13407 bool result;
13408
13409 op1 = EX_VAR(opline->op1.var);
13410 op2 = RT_CONSTANT(opline, opline->op2);
13411 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13412 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13413 }
13414
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13415 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13416 {
13417 USE_OPLINE
13418 zval *op1, *op2;
13419 bool result;
13420
13421 op1 = EX_VAR(opline->op1.var);
13422 op2 = RT_CONSTANT(opline, opline->op2);
13423 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13424 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13425 }
13426
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13427 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13428 {
13429 USE_OPLINE
13430 zval *op1, *op2;
13431 bool result;
13432
13433 op1 = EX_VAR(opline->op1.var);
13434 op2 = RT_CONSTANT(opline, opline->op2);
13435 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13436 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13437 }
13438
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13439 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13440 {
13441 USE_OPLINE
13442 zval *op1, *op2;
13443 bool result;
13444
13445 op1 = EX_VAR(opline->op1.var);
13446 op2 = RT_CONSTANT(opline, opline->op2);
13447 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13448 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13449 }
13450
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13451 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13452 {
13453 USE_OPLINE
13454 zval *op1, *op2;
13455 bool result;
13456
13457 op1 = EX_VAR(opline->op1.var);
13458 op2 = RT_CONSTANT(opline, opline->op2);
13459 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13460 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13461 }
13462
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13463 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13464 {
13465 USE_OPLINE
13466 zval *op1, *op2;
13467 bool result;
13468
13469 op1 = EX_VAR(opline->op1.var);
13470 op2 = RT_CONSTANT(opline, opline->op2);
13471 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13472 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13473 }
13474
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13475 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13476 {
13477 USE_OPLINE
13478 zval *op1, *op2;
13479 bool result;
13480
13481 op1 = EX_VAR(opline->op1.var);
13482 op2 = RT_CONSTANT(opline, opline->op2);
13483 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13484 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13485 }
13486
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13487 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13488 {
13489 USE_OPLINE
13490 zval *op1, *op2;
13491 bool result;
13492
13493 op1 = EX_VAR(opline->op1.var);
13494 op2 = RT_CONSTANT(opline, opline->op2);
13495 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13496 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13497 }
13498
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13499 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13500 {
13501 USE_OPLINE
13502 zval *op1, *op2;
13503 bool result;
13504
13505 op1 = EX_VAR(opline->op1.var);
13506 op2 = RT_CONSTANT(opline, opline->op2);
13507 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13508 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13509 }
13510
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13511 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13512 {
13513 USE_OPLINE
13514 zval *op1, *op2;
13515 bool result;
13516
13517 op1 = EX_VAR(opline->op1.var);
13518 op2 = RT_CONSTANT(opline, opline->op2);
13519 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13520 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13521 }
13522
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13523 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13524 {
13525 USE_OPLINE
13526 zval *op1, *op2;
13527 bool result;
13528
13529 op1 = EX_VAR(opline->op1.var);
13530 op2 = RT_CONSTANT(opline, opline->op2);
13531 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13532 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13533 }
13534
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13535 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13536 {
13537 USE_OPLINE
13538 zval *op1, *op2;
13539 bool result;
13540
13541 op1 = EX_VAR(opline->op1.var);
13542 op2 = RT_CONSTANT(opline, opline->op2);
13543 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13544 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13545 }
13546
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13547 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13548 {
13549 USE_OPLINE
13550 zval *op1, *op2;
13551 bool result;
13552
13553 op1 = EX_VAR(opline->op1.var);
13554 op2 = RT_CONSTANT(opline, opline->op2);
13555 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13556 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13557 }
13558
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13559 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)
13560 {
13561 USE_OPLINE
13562 zval *op1, *op2;
13563 bool result;
13564
13565 op1 = EX_VAR(opline->op1.var);
13566 op2 = RT_CONSTANT(opline, opline->op2);
13567 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13568 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13569 }
13570
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13571 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)
13572 {
13573 USE_OPLINE
13574 zval *op1, *op2;
13575 bool result;
13576
13577 op1 = EX_VAR(opline->op1.var);
13578 op2 = RT_CONSTANT(opline, opline->op2);
13579 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13580 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13581 }
13582
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13583 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13584 {
13585 USE_OPLINE
13586 zval *op1, *op2;
13587 bool result;
13588
13589 op1 = EX_VAR(opline->op1.var);
13590 op2 = RT_CONSTANT(opline, opline->op2);
13591 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13592 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13593 }
13594
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13595 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)
13596 {
13597 USE_OPLINE
13598 zval *op1, *op2;
13599 bool result;
13600
13601 op1 = EX_VAR(opline->op1.var);
13602 op2 = RT_CONSTANT(opline, opline->op2);
13603 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13604 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13605 }
13606
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13607 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)
13608 {
13609 USE_OPLINE
13610 zval *op1, *op2;
13611 bool result;
13612
13613 op1 = EX_VAR(opline->op1.var);
13614 op2 = RT_CONSTANT(opline, opline->op2);
13615 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13616 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13617 }
13618
ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13619 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13620 {
13621 USE_OPLINE
13622 zval *op1, *op2, *result;
13623 double d1, d2;
13624
13625 op1 = EX_VAR(opline->op1.var);
13626 op2 = EX_VAR(opline->op2.var);
13627 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13628 /* pass */
13629 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13630 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13631 result = EX_VAR(opline->result.var);
13632 fast_long_add_function(result, op1, op2);
13633 ZEND_VM_NEXT_OPCODE();
13634 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13635 d1 = (double)Z_LVAL_P(op1);
13636 d2 = Z_DVAL_P(op2);
13637 goto add_double;
13638 }
13639 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13640 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13641 d1 = Z_DVAL_P(op1);
13642 d2 = Z_DVAL_P(op2);
13643 add_double:
13644 result = EX_VAR(opline->result.var);
13645 ZVAL_DOUBLE(result, d1 + d2);
13646 ZEND_VM_NEXT_OPCODE();
13647 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13648 d1 = Z_DVAL_P(op1);
13649 d2 = (double)Z_LVAL_P(op2);
13650 goto add_double;
13651 }
13652 }
13653
13654 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13655 }
13656
ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13657 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13658 {
13659 USE_OPLINE
13660 zval *op1, *op2, *result;
13661 double d1, d2;
13662
13663 op1 = EX_VAR(opline->op1.var);
13664 op2 = EX_VAR(opline->op2.var);
13665 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13666 /* pass */
13667 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13668 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13669 result = EX_VAR(opline->result.var);
13670 fast_long_sub_function(result, op1, op2);
13671 ZEND_VM_NEXT_OPCODE();
13672 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13673 d1 = (double)Z_LVAL_P(op1);
13674 d2 = Z_DVAL_P(op2);
13675 goto sub_double;
13676 }
13677 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13678 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13679 d1 = Z_DVAL_P(op1);
13680 d2 = Z_DVAL_P(op2);
13681 sub_double:
13682 result = EX_VAR(opline->result.var);
13683 ZVAL_DOUBLE(result, d1 - d2);
13684 ZEND_VM_NEXT_OPCODE();
13685 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13686 d1 = Z_DVAL_P(op1);
13687 d2 = (double)Z_LVAL_P(op2);
13688 goto sub_double;
13689 }
13690 }
13691
13692 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13693 }
13694
ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13695 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13696 {
13697 USE_OPLINE
13698 zval *op1, *op2, *result;
13699 double d1, d2;
13700
13701 op1 = EX_VAR(opline->op1.var);
13702 op2 = EX_VAR(opline->op2.var);
13703 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13704 /* pass */
13705 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13706 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13707 zend_long overflow;
13708
13709 result = EX_VAR(opline->result.var);
13710 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13711 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13712 ZEND_VM_NEXT_OPCODE();
13713 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13714 d1 = (double)Z_LVAL_P(op1);
13715 d2 = Z_DVAL_P(op2);
13716 goto mul_double;
13717 }
13718 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13719 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13720 d1 = Z_DVAL_P(op1);
13721 d2 = Z_DVAL_P(op2);
13722 mul_double:
13723 result = EX_VAR(opline->result.var);
13724 ZVAL_DOUBLE(result, d1 * d2);
13725 ZEND_VM_NEXT_OPCODE();
13726 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13727 d1 = Z_DVAL_P(op1);
13728 d2 = (double)Z_LVAL_P(op2);
13729 goto mul_double;
13730 }
13731 }
13732
13733 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13734 }
13735
ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13736 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13737 {
13738 USE_OPLINE
13739 zval *op1, *op2, *result;
13740
13741 op1 = EX_VAR(opline->op1.var);
13742 op2 = EX_VAR(opline->op2.var);
13743 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13744 /* pass */
13745 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13746 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13747 result = EX_VAR(opline->result.var);
13748 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
13749 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
13750 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
13751 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
13752 ZVAL_LONG(result, 0);
13753 } else {
13754 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
13755 }
13756 ZEND_VM_NEXT_OPCODE();
13757 }
13758 }
13759
13760 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13761 }
13762
ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13763 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13764 {
13765 USE_OPLINE
13766 zval *op1, *op2;
13767
13768 op1 = EX_VAR(opline->op1.var);
13769 op2 = EX_VAR(opline->op2.var);
13770 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13771 /* pass */
13772 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13773 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13774 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13775 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
13776 ZVAL_LONG(EX_VAR(opline->result.var),
13777 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
13778 ZEND_VM_NEXT_OPCODE();
13779 }
13780
13781 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13782 }
13783
ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13784 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13785 {
13786 USE_OPLINE
13787 zval *op1, *op2;
13788
13789 op1 = EX_VAR(opline->op1.var);
13790 op2 = EX_VAR(opline->op2.var);
13791 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13792 /* pass */
13793 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13794 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13795 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13796 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
13797 ZEND_VM_NEXT_OPCODE();
13798 }
13799
13800 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13801 }
13802
ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13803 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13804 {
13805 USE_OPLINE
13806 zval *op1, *op2;
13807 double d1, d2;
13808
13809 op1 = EX_VAR(opline->op1.var);
13810 op2 = EX_VAR(opline->op2.var);
13811 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13812 /* pass */
13813 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13814 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13815 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13816 is_smaller_true:
13817 ZEND_VM_SMART_BRANCH_TRUE_NONE();
13818 } else {
13819 is_smaller_false:
13820 ZEND_VM_SMART_BRANCH_FALSE_NONE();
13821 }
13822 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13823 d1 = (double)Z_LVAL_P(op1);
13824 d2 = Z_DVAL_P(op2);
13825 goto is_smaller_double;
13826 }
13827 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13828 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13829 d1 = Z_DVAL_P(op1);
13830 d2 = Z_DVAL_P(op2);
13831 is_smaller_double:
13832 if (d1 < d2) {
13833 goto is_smaller_true;
13834 } else {
13835 goto is_smaller_false;
13836 }
13837 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13838 d1 = Z_DVAL_P(op1);
13839 d2 = (double)Z_LVAL_P(op2);
13840 goto is_smaller_double;
13841 }
13842 }
13843 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13844 }
13845
ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13846 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13847 {
13848 USE_OPLINE
13849 zval *op1, *op2;
13850 double d1, d2;
13851
13852 op1 = EX_VAR(opline->op1.var);
13853 op2 = EX_VAR(opline->op2.var);
13854 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13855 /* pass */
13856 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13857 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13858 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13859 is_smaller_true:
13860 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13861 } else {
13862 is_smaller_false:
13863 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13864 }
13865 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13866 d1 = (double)Z_LVAL_P(op1);
13867 d2 = Z_DVAL_P(op2);
13868 goto is_smaller_double;
13869 }
13870 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13871 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13872 d1 = Z_DVAL_P(op1);
13873 d2 = Z_DVAL_P(op2);
13874 is_smaller_double:
13875 if (d1 < d2) {
13876 goto is_smaller_true;
13877 } else {
13878 goto is_smaller_false;
13879 }
13880 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13881 d1 = Z_DVAL_P(op1);
13882 d2 = (double)Z_LVAL_P(op2);
13883 goto is_smaller_double;
13884 }
13885 }
13886 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13887 }
13888
ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13889 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13890 {
13891 USE_OPLINE
13892 zval *op1, *op2;
13893 double d1, d2;
13894
13895 op1 = EX_VAR(opline->op1.var);
13896 op2 = EX_VAR(opline->op2.var);
13897 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13898 /* pass */
13899 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13900 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13901 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13902 is_smaller_true:
13903 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13904 } else {
13905 is_smaller_false:
13906 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13907 }
13908 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13909 d1 = (double)Z_LVAL_P(op1);
13910 d2 = Z_DVAL_P(op2);
13911 goto is_smaller_double;
13912 }
13913 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13914 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13915 d1 = Z_DVAL_P(op1);
13916 d2 = Z_DVAL_P(op2);
13917 is_smaller_double:
13918 if (d1 < d2) {
13919 goto is_smaller_true;
13920 } else {
13921 goto is_smaller_false;
13922 }
13923 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13924 d1 = Z_DVAL_P(op1);
13925 d2 = (double)Z_LVAL_P(op2);
13926 goto is_smaller_double;
13927 }
13928 }
13929 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13930 }
13931
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13932 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13933 {
13934 USE_OPLINE
13935 zval *op1, *op2;
13936 double d1, d2;
13937
13938 op1 = EX_VAR(opline->op1.var);
13939 op2 = EX_VAR(opline->op2.var);
13940 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13941 /* pass */
13942 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13943 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13944 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13945 is_smaller_or_equal_true:
13946 ZEND_VM_SMART_BRANCH_TRUE_NONE();
13947 ZVAL_TRUE(EX_VAR(opline->result.var));
13948 ZEND_VM_NEXT_OPCODE();
13949 } else {
13950 is_smaller_or_equal_false:
13951 ZEND_VM_SMART_BRANCH_FALSE_NONE();
13952 ZVAL_FALSE(EX_VAR(opline->result.var));
13953 ZEND_VM_NEXT_OPCODE();
13954 }
13955 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13956 d1 = (double)Z_LVAL_P(op1);
13957 d2 = Z_DVAL_P(op2);
13958 goto is_smaller_or_equal_double;
13959 }
13960 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13961 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13962 d1 = Z_DVAL_P(op1);
13963 d2 = Z_DVAL_P(op2);
13964 is_smaller_or_equal_double:
13965 if (d1 <= d2) {
13966 goto is_smaller_or_equal_true;
13967 } else {
13968 goto is_smaller_or_equal_false;
13969 }
13970 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13971 d1 = Z_DVAL_P(op1);
13972 d2 = (double)Z_LVAL_P(op2);
13973 goto is_smaller_or_equal_double;
13974 }
13975 }
13976 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13977 }
13978
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13979 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13980 {
13981 USE_OPLINE
13982 zval *op1, *op2;
13983 double d1, d2;
13984
13985 op1 = EX_VAR(opline->op1.var);
13986 op2 = EX_VAR(opline->op2.var);
13987 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13988 /* pass */
13989 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13990 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13991 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13992 is_smaller_or_equal_true:
13993 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13994 ZVAL_TRUE(EX_VAR(opline->result.var));
13995 ZEND_VM_NEXT_OPCODE();
13996 } else {
13997 is_smaller_or_equal_false:
13998 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13999 ZVAL_FALSE(EX_VAR(opline->result.var));
14000 ZEND_VM_NEXT_OPCODE();
14001 }
14002 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14003 d1 = (double)Z_LVAL_P(op1);
14004 d2 = Z_DVAL_P(op2);
14005 goto is_smaller_or_equal_double;
14006 }
14007 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14008 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14009 d1 = Z_DVAL_P(op1);
14010 d2 = Z_DVAL_P(op2);
14011 is_smaller_or_equal_double:
14012 if (d1 <= d2) {
14013 goto is_smaller_or_equal_true;
14014 } else {
14015 goto is_smaller_or_equal_false;
14016 }
14017 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14018 d1 = Z_DVAL_P(op1);
14019 d2 = (double)Z_LVAL_P(op2);
14020 goto is_smaller_or_equal_double;
14021 }
14022 }
14023 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14024 }
14025
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14026 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14027 {
14028 USE_OPLINE
14029 zval *op1, *op2;
14030 double d1, d2;
14031
14032 op1 = EX_VAR(opline->op1.var);
14033 op2 = EX_VAR(opline->op2.var);
14034 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14035 /* pass */
14036 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14037 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14038 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14039 is_smaller_or_equal_true:
14040 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
14041 ZVAL_TRUE(EX_VAR(opline->result.var));
14042 ZEND_VM_NEXT_OPCODE();
14043 } else {
14044 is_smaller_or_equal_false:
14045 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
14046 ZVAL_FALSE(EX_VAR(opline->result.var));
14047 ZEND_VM_NEXT_OPCODE();
14048 }
14049 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14050 d1 = (double)Z_LVAL_P(op1);
14051 d2 = Z_DVAL_P(op2);
14052 goto is_smaller_or_equal_double;
14053 }
14054 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14055 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14056 d1 = Z_DVAL_P(op1);
14057 d2 = Z_DVAL_P(op2);
14058 is_smaller_or_equal_double:
14059 if (d1 <= d2) {
14060 goto is_smaller_or_equal_true;
14061 } else {
14062 goto is_smaller_or_equal_false;
14063 }
14064 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14065 d1 = Z_DVAL_P(op1);
14066 d2 = (double)Z_LVAL_P(op2);
14067 goto is_smaller_or_equal_double;
14068 }
14069 }
14070 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14071 }
14072
ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14073 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_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_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14089 }
14090
ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14091 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_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_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14107 }
14108
ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14109 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14110 {
14111 USE_OPLINE
14112 zval *op1, *op2;
14113
14114 op1 = EX_VAR(opline->op1.var);
14115 op2 = EX_VAR(opline->op2.var);
14116 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14117 /* pass */
14118 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14119 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14120 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
14121 ZEND_VM_NEXT_OPCODE();
14122 }
14123
14124 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14125 }
14126
ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14127 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14128 {
14129 USE_OPLINE
14130 zval *op1, *op2, *result;
14131
14132 op1 = EX_VAR(opline->op1.var);
14133 op2 = EX_VAR(opline->op2.var);
14134 result = EX_VAR(opline->result.var);
14135 ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
14136 ZEND_VM_NEXT_OPCODE();
14137 }
14138
ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14139 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14140 {
14141 USE_OPLINE
14142 zval *op1, *op2, *result;
14143
14144 op1 = EX_VAR(opline->op1.var);
14145 op2 = EX_VAR(opline->op2.var);
14146 result = EX_VAR(opline->result.var);
14147 fast_long_add_function(result, op1, op2);
14148 ZEND_VM_NEXT_OPCODE();
14149 }
14150
ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14151 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14152 {
14153 USE_OPLINE
14154 zval *op1, *op2, *result;
14155
14156 op1 = EX_VAR(opline->op1.var);
14157 op2 = EX_VAR(opline->op2.var);
14158 result = EX_VAR(opline->result.var);
14159 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
14160 ZEND_VM_NEXT_OPCODE();
14161 }
14162
ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14163 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14164 {
14165 USE_OPLINE
14166 zval *op1, *op2, *result;
14167
14168 op1 = EX_VAR(opline->op1.var);
14169 op2 = EX_VAR(opline->op2.var);
14170 result = EX_VAR(opline->result.var);
14171 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
14172 ZEND_VM_NEXT_OPCODE();
14173 }
14174
ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14175 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14176 {
14177 USE_OPLINE
14178 zval *op1, *op2, *result;
14179
14180 op1 = EX_VAR(opline->op1.var);
14181 op2 = EX_VAR(opline->op2.var);
14182 result = EX_VAR(opline->result.var);
14183 fast_long_sub_function(result, op1, op2);
14184 ZEND_VM_NEXT_OPCODE();
14185 }
14186
ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14187 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14188 {
14189 USE_OPLINE
14190 zval *op1, *op2, *result;
14191
14192 op1 = EX_VAR(opline->op1.var);
14193 op2 = EX_VAR(opline->op2.var);
14194 result = EX_VAR(opline->result.var);
14195 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
14196 ZEND_VM_NEXT_OPCODE();
14197 }
14198
ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14199 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14200 {
14201 USE_OPLINE
14202 zval *op1, *op2, *result;
14203
14204 op1 = EX_VAR(opline->op1.var);
14205 op2 = EX_VAR(opline->op2.var);
14206 result = EX_VAR(opline->result.var);
14207 ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
14208 ZEND_VM_NEXT_OPCODE();
14209 }
14210
ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14211 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14212 {
14213 USE_OPLINE
14214 zval *op1, *op2, *result;
14215 zend_long overflow;
14216
14217 op1 = EX_VAR(opline->op1.var);
14218 op2 = EX_VAR(opline->op2.var);
14219 result = EX_VAR(opline->result.var);
14220 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
14221 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
14222 ZEND_VM_NEXT_OPCODE();
14223 }
14224
ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14225 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14226 {
14227 USE_OPLINE
14228 zval *op1, *op2, *result;
14229
14230 op1 = EX_VAR(opline->op1.var);
14231 op2 = EX_VAR(opline->op2.var);
14232 result = EX_VAR(opline->result.var);
14233 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
14234 ZEND_VM_NEXT_OPCODE();
14235 }
14236
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14237 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14238 {
14239 USE_OPLINE
14240 zval *op1, *op2;
14241 bool result;
14242
14243 op1 = EX_VAR(opline->op1.var);
14244 op2 = EX_VAR(opline->op2.var);
14245 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14246 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14247 }
14248
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14249 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14250 {
14251 USE_OPLINE
14252 zval *op1, *op2;
14253 bool result;
14254
14255 op1 = EX_VAR(opline->op1.var);
14256 op2 = EX_VAR(opline->op2.var);
14257 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14258 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14259 }
14260
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14261 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14262 {
14263 USE_OPLINE
14264 zval *op1, *op2;
14265 bool result;
14266
14267 op1 = EX_VAR(opline->op1.var);
14268 op2 = EX_VAR(opline->op2.var);
14269 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14270 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14271 }
14272
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14273 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14274 {
14275 USE_OPLINE
14276 zval *op1, *op2;
14277 bool result;
14278
14279 op1 = EX_VAR(opline->op1.var);
14280 op2 = EX_VAR(opline->op2.var);
14281 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14282 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14283 }
14284
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14285 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14286 {
14287 USE_OPLINE
14288 zval *op1, *op2;
14289 bool result;
14290
14291 op1 = EX_VAR(opline->op1.var);
14292 op2 = EX_VAR(opline->op2.var);
14293 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14294 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14295 }
14296
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14297 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14298 {
14299 USE_OPLINE
14300 zval *op1, *op2;
14301 bool result;
14302
14303 op1 = EX_VAR(opline->op1.var);
14304 op2 = EX_VAR(opline->op2.var);
14305 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14306 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14307 }
14308
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14309 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14310 {
14311 USE_OPLINE
14312 zval *op1, *op2;
14313 bool result;
14314
14315 op1 = EX_VAR(opline->op1.var);
14316 op2 = EX_VAR(opline->op2.var);
14317 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14318 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14319 }
14320
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14321 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14322 {
14323 USE_OPLINE
14324 zval *op1, *op2;
14325 bool result;
14326
14327 op1 = EX_VAR(opline->op1.var);
14328 op2 = EX_VAR(opline->op2.var);
14329 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14330 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14331 }
14332
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14333 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14334 {
14335 USE_OPLINE
14336 zval *op1, *op2;
14337 bool result;
14338
14339 op1 = EX_VAR(opline->op1.var);
14340 op2 = EX_VAR(opline->op2.var);
14341 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14342 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14343 }
14344
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14345 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14346 {
14347 USE_OPLINE
14348 zval *op1, *op2;
14349 bool result;
14350
14351 op1 = EX_VAR(opline->op1.var);
14352 op2 = EX_VAR(opline->op2.var);
14353 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14354 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14355 }
14356
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14357 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14358 {
14359 USE_OPLINE
14360 zval *op1, *op2;
14361 bool result;
14362
14363 op1 = EX_VAR(opline->op1.var);
14364 op2 = EX_VAR(opline->op2.var);
14365 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14366 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14367 }
14368
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14369 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14370 {
14371 USE_OPLINE
14372 zval *op1, *op2;
14373 bool result;
14374
14375 op1 = EX_VAR(opline->op1.var);
14376 op2 = EX_VAR(opline->op2.var);
14377 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14378 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14379 }
14380
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14381 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14382 {
14383 USE_OPLINE
14384 zval *op1, *op2;
14385 bool result;
14386
14387 op1 = EX_VAR(opline->op1.var);
14388 op2 = EX_VAR(opline->op2.var);
14389 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14390 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14391 }
14392
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14393 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14394 {
14395 USE_OPLINE
14396 zval *op1, *op2;
14397 bool result;
14398
14399 op1 = EX_VAR(opline->op1.var);
14400 op2 = EX_VAR(opline->op2.var);
14401 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14402 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14403 }
14404
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14405 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14406 {
14407 USE_OPLINE
14408 zval *op1, *op2;
14409 bool result;
14410
14411 op1 = EX_VAR(opline->op1.var);
14412 op2 = EX_VAR(opline->op2.var);
14413 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14414 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14415 }
14416
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14417 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14418 {
14419 USE_OPLINE
14420 zval *op1, *op2;
14421 bool result;
14422
14423 op1 = EX_VAR(opline->op1.var);
14424 op2 = EX_VAR(opline->op2.var);
14425 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14426 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14427 }
14428
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14429 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14430 {
14431 USE_OPLINE
14432 zval *op1, *op2;
14433 bool result;
14434
14435 op1 = EX_VAR(opline->op1.var);
14436 op2 = EX_VAR(opline->op2.var);
14437 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14438 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14439 }
14440
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14441 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14442 {
14443 USE_OPLINE
14444 zval *op1, *op2;
14445 bool result;
14446
14447 op1 = EX_VAR(opline->op1.var);
14448 op2 = EX_VAR(opline->op2.var);
14449 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14450 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14451 }
14452
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14453 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14454 {
14455 USE_OPLINE
14456 zval *op1, *op2;
14457 bool result;
14458
14459 op1 = EX_VAR(opline->op1.var);
14460 op2 = EX_VAR(opline->op2.var);
14461 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14462 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14463 }
14464
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14465 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)
14466 {
14467 USE_OPLINE
14468 zval *op1, *op2;
14469 bool result;
14470
14471 op1 = EX_VAR(opline->op1.var);
14472 op2 = EX_VAR(opline->op2.var);
14473 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14474 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14475 }
14476
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14477 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)
14478 {
14479 USE_OPLINE
14480 zval *op1, *op2;
14481 bool result;
14482
14483 op1 = EX_VAR(opline->op1.var);
14484 op2 = EX_VAR(opline->op2.var);
14485 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14486 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14487 }
14488
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14489 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14490 {
14491 USE_OPLINE
14492 zval *op1, *op2;
14493 bool result;
14494
14495 op1 = EX_VAR(opline->op1.var);
14496 op2 = EX_VAR(opline->op2.var);
14497 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14498 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14499 }
14500
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14501 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)
14502 {
14503 USE_OPLINE
14504 zval *op1, *op2;
14505 bool result;
14506
14507 op1 = EX_VAR(opline->op1.var);
14508 op2 = EX_VAR(opline->op2.var);
14509 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14510 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14511 }
14512
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14513 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)
14514 {
14515 USE_OPLINE
14516 zval *op1, *op2;
14517 bool result;
14518
14519 op1 = EX_VAR(opline->op1.var);
14520 op2 = EX_VAR(opline->op2.var);
14521 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14522 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14523 }
14524
ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14525 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14526 {
14527 USE_OPLINE
14528 zval *container;
14529
14530 SAVE_OPLINE();
14531 container = EX_VAR(opline->op1.var);
14532 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);
14533 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
14534 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14535 }
14536
ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14537 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14538 {
14539 USE_OPLINE
14540 zval *op;
14541
14542 SAVE_OPLINE();
14543 op = EX_VAR(opline->op1.var);
14544 zend_match_unhandled_error(op);
14545 HANDLE_EXCEPTION();
14546 }
14547
ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14548 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14549 {
14550 USE_OPLINE
14551 zval *container;
14552
14553 SAVE_OPLINE();
14554 container = EX_VAR(opline->op1.var);
14555 zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
14556
14557 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14558 }
14559
ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14560 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14561 {
14562 USE_OPLINE
14563 zval *val;
14564
14565 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14566 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14567 ZVAL_FALSE(EX_VAR(opline->result.var));
14568 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14569 /* The result and op1 can be the same cv zval */
14570 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
14571 ZVAL_TRUE(EX_VAR(opline->result.var));
14572 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
14573 SAVE_OPLINE();
14574 ZVAL_UNDEFINED_OP1();
14575 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14576 }
14577 } else {
14578 SAVE_OPLINE();
14579 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
14580 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14581 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14582 }
14583 ZEND_VM_NEXT_OPCODE();
14584 }
14585
ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14586 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14587 {
14588 USE_OPLINE
14589 zval *z;
14590
14591 SAVE_OPLINE();
14592 z = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14593
14594 if (Z_TYPE_P(z) == IS_STRING) {
14595 zend_string *str = Z_STR_P(z);
14596
14597 if (ZSTR_LEN(str) != 0) {
14598 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
14599 }
14600 } else {
14601 zend_string *str = zval_get_string_func(z);
14602
14603 if (ZSTR_LEN(str) != 0) {
14604 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
14605 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
14606 ZVAL_UNDEFINED_OP1();
14607 }
14608 zend_string_release_ex(str, 0);
14609 }
14610
14611 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14612 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14613 }
14614
ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14615 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14616 {
14617 USE_OPLINE
14618 zval *val;
14619 uint8_t op1_type;
14620
14621 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14622
14623 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14624 ZEND_VM_NEXT_OPCODE();
14625 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14626 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
14627 SAVE_OPLINE();
14628 ZVAL_UNDEFINED_OP1();
14629 if (UNEXPECTED(EG(exception))) {
14630 HANDLE_EXCEPTION();
14631 }
14632 }
14633 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
14634 }
14635
14636 SAVE_OPLINE();
14637 op1_type = (IS_TMP_VAR|IS_VAR);
14638 if (i_zend_is_true(val)) {
14639 opline++;
14640 } else {
14641 opline = OP_JMP_ADDR(opline, opline->op2);
14642 }
14643 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
14644 zval_ptr_dtor_nogc(val);
14645 }
14646 ZEND_VM_JMP(opline);
14647 }
14648
ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14649 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14650 {
14651 USE_OPLINE
14652 zval *val;
14653 uint8_t op1_type;
14654
14655 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14656
14657 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14658 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
14659 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14660 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
14661 SAVE_OPLINE();
14662 ZVAL_UNDEFINED_OP1();
14663 if (UNEXPECTED(EG(exception))) {
14664 HANDLE_EXCEPTION();
14665 }
14666 }
14667 ZEND_VM_NEXT_OPCODE();
14668 }
14669
14670 SAVE_OPLINE();
14671 op1_type = (IS_TMP_VAR|IS_VAR);
14672 if (i_zend_is_true(val)) {
14673 opline = OP_JMP_ADDR(opline, opline->op2);
14674 } else {
14675 opline++;
14676 }
14677 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
14678 zval_ptr_dtor_nogc(val);
14679 }
14680 ZEND_VM_JMP(opline);
14681 }
14682
ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14683 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14684 {
14685 USE_OPLINE
14686 zval *val;
14687 bool ret;
14688
14689 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14690
14691 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14692 ZVAL_TRUE(EX_VAR(opline->result.var));
14693 ZEND_VM_NEXT_OPCODE();
14694 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14695 ZVAL_FALSE(EX_VAR(opline->result.var));
14696 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
14697 SAVE_OPLINE();
14698 ZVAL_UNDEFINED_OP1();
14699 if (UNEXPECTED(EG(exception))) {
14700 HANDLE_EXCEPTION();
14701 }
14702 }
14703 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
14704 }
14705
14706 SAVE_OPLINE();
14707 ret = i_zend_is_true(val);
14708 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14709 if (ret) {
14710 ZVAL_TRUE(EX_VAR(opline->result.var));
14711 opline++;
14712 } else {
14713 ZVAL_FALSE(EX_VAR(opline->result.var));
14714 opline = OP_JMP_ADDR(opline, opline->op2);
14715 }
14716 ZEND_VM_JMP(opline);
14717 }
14718
ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14719 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14720 {
14721 USE_OPLINE
14722 zval *val;
14723 bool ret;
14724
14725 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14726
14727 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14728 ZVAL_TRUE(EX_VAR(opline->result.var));
14729 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
14730 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14731 ZVAL_FALSE(EX_VAR(opline->result.var));
14732 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
14733 SAVE_OPLINE();
14734 ZVAL_UNDEFINED_OP1();
14735 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14736 } else {
14737 ZEND_VM_NEXT_OPCODE();
14738 }
14739 }
14740
14741 SAVE_OPLINE();
14742 ret = i_zend_is_true(val);
14743 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14744 if (ret) {
14745 ZVAL_TRUE(EX_VAR(opline->result.var));
14746 opline = OP_JMP_ADDR(opline, opline->op2);
14747 } else {
14748 ZVAL_FALSE(EX_VAR(opline->result.var));
14749 opline++;
14750 }
14751 ZEND_VM_JMP(opline);
14752 }
14753
ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14754 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14755 {
14756 USE_OPLINE
14757
14758 SAVE_OPLINE();
14759 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14760 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14761 }
14762
ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14763 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14764 {
14765 zval *var;
14766 USE_OPLINE
14767
14768 var = EX_VAR(opline->op1.var);
14769 if (Z_TYPE_P(var) != IS_ARRAY) {
14770 SAVE_OPLINE();
14771 if (Z_FE_ITER_P(var) != (uint32_t)-1) {
14772 zend_hash_iterator_del(Z_FE_ITER_P(var));
14773 }
14774 zval_ptr_dtor_nogc(var);
14775 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14776 }
14777
14778 /* This is freeing an array. Use an inlined version of zval_ptr_dtor_nogc. */
14779 /* 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) */
14780 if (Z_REFCOUNTED_P(var) && !Z_DELREF_P(var)) {
14781 SAVE_OPLINE();
14782 rc_dtor_func(Z_COUNTED_P(var));
14783 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14784 }
14785 ZEND_VM_NEXT_OPCODE();
14786 }
14787
ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14788 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14789 {
14790 USE_OPLINE
14791 zval *value;
14792
14793 SAVE_OPLINE();
14794 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14795
14796 do {
14797 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
14798 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
14799 value = Z_REFVAL_P(value);
14800 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
14801 break;
14802 }
14803 }
14804 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
14805 ZVAL_UNDEFINED_OP1();
14806 if (UNEXPECTED(EG(exception) != NULL)) {
14807 HANDLE_EXCEPTION();
14808 }
14809 }
14810 zend_throw_error(NULL, "Can only throw objects");
14811 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14812 HANDLE_EXCEPTION();
14813 }
14814 } while (0);
14815
14816 zend_exception_save();
14817 Z_TRY_ADDREF_P(value);
14818 zend_throw_exception_object(value);
14819 zend_exception_restore();
14820 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14821 HANDLE_EXCEPTION();
14822 }
14823
ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14824 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14825 {
14826 USE_OPLINE
14827 zval *val;
14828
14829 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14830 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14831 ZVAL_TRUE(EX_VAR(opline->result.var));
14832 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14833 /* The result and op1 can be the same cv zval */
14834 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
14835 ZVAL_FALSE(EX_VAR(opline->result.var));
14836 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
14837 SAVE_OPLINE();
14838 ZVAL_UNDEFINED_OP1();
14839 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14840 }
14841 } else {
14842 SAVE_OPLINE();
14843 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
14844 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14845 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14846 }
14847 ZEND_VM_NEXT_OPCODE();
14848 }
14849
ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14850 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14851 {
14852 USE_OPLINE
14853 zval *obj;
14854 zend_object *zobj;
14855 zend_class_entry *ce, *scope;
14856 zend_function *clone;
14857 zend_object_clone_obj_t clone_call;
14858
14859 SAVE_OPLINE();
14860 obj = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14861
14862 do {
14863 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
14864 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
14865 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
14866 obj = Z_REFVAL_P(obj);
14867 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
14868 break;
14869 }
14870 }
14871 ZVAL_UNDEF(EX_VAR(opline->result.var));
14872 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
14873 ZVAL_UNDEFINED_OP1();
14874 if (UNEXPECTED(EG(exception) != NULL)) {
14875 HANDLE_EXCEPTION();
14876 }
14877 }
14878 zend_throw_error(NULL, "__clone method called on non-object");
14879 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14880 HANDLE_EXCEPTION();
14881 }
14882 } while (0);
14883
14884 zobj = Z_OBJ_P(obj);
14885 ce = zobj->ce;
14886 clone = ce->clone;
14887 clone_call = zobj->handlers->clone_obj;
14888 if (UNEXPECTED(clone_call == NULL)) {
14889 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
14890 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14891 ZVAL_UNDEF(EX_VAR(opline->result.var));
14892 HANDLE_EXCEPTION();
14893 }
14894
14895 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
14896 scope = EX(func)->op_array.scope;
14897 if (clone->common.scope != scope) {
14898 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
14899 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
14900 zend_wrong_clone_call(clone, scope);
14901 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14902 ZVAL_UNDEF(EX_VAR(opline->result.var));
14903 HANDLE_EXCEPTION();
14904 }
14905 }
14906 }
14907
14908 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
14909
14910 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14911 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14912 }
14913
ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14914 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14915 {
14916 USE_OPLINE
14917 zend_op_array *new_op_array;
14918 zval *inc_filename;
14919
14920 SAVE_OPLINE();
14921 inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14922 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
14923 if (UNEXPECTED(EG(exception) != NULL)) {
14924 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14925 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
14926 destroy_op_array(new_op_array);
14927 efree_size(new_op_array, sizeof(zend_op_array));
14928 }
14929 UNDEF_RESULT();
14930 HANDLE_EXCEPTION();
14931 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
14932 if (RETURN_VALUE_USED(opline)) {
14933 ZVAL_TRUE(EX_VAR(opline->result.var));
14934 }
14935 } else if (UNEXPECTED(new_op_array == NULL)) {
14936 if (RETURN_VALUE_USED(opline)) {
14937 ZVAL_FALSE(EX_VAR(opline->result.var));
14938 }
14939 } else if (new_op_array->last == 1
14940 && new_op_array->opcodes[0].opcode == ZEND_RETURN
14941 && new_op_array->opcodes[0].op1_type == IS_CONST
14942 && EXPECTED(zend_execute_ex == execute_ex)) {
14943 if (RETURN_VALUE_USED(opline)) {
14944 const zend_op *op = new_op_array->opcodes;
14945
14946 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
14947 }
14948 zend_destroy_static_vars(new_op_array);
14949 destroy_op_array(new_op_array);
14950 efree_size(new_op_array, sizeof(zend_op_array));
14951 } else {
14952 zval *return_value = NULL;
14953 zend_execute_data *call;
14954 if (RETURN_VALUE_USED(opline)) {
14955 return_value = EX_VAR(opline->result.var);
14956 }
14957
14958 new_op_array->scope = EX(func)->op_array.scope;
14959
14960 call = zend_vm_stack_push_call_frame(
14961 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
14962 (zend_function*)new_op_array, 0,
14963 Z_PTR(EX(This)));
14964
14965 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
14966 call->symbol_table = EX(symbol_table);
14967 } else {
14968 call->symbol_table = zend_rebuild_symbol_table();
14969 }
14970
14971 call->prev_execute_data = execute_data;
14972 i_init_code_execute_data(call, new_op_array, return_value);
14973
14974 if (EXPECTED(zend_execute_ex == execute_ex)) {
14975 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14976 ZEND_VM_ENTER();
14977 } else {
14978 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
14979 zend_execute_ex(call);
14980 zend_vm_stack_free_call_frame(call);
14981 }
14982
14983 zend_destroy_static_vars(new_op_array);
14984 destroy_op_array(new_op_array);
14985 efree_size(new_op_array, sizeof(zend_op_array));
14986 if (UNEXPECTED(EG(exception) != NULL)) {
14987 zend_rethrow_exception(execute_data);
14988 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14989 UNDEF_RESULT();
14990 HANDLE_EXCEPTION();
14991 }
14992 }
14993 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14994 ZEND_VM_NEXT_OPCODE();
14995 }
14996
ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14997 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14998 {
14999 USE_OPLINE
15000 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
15001 zval *val;
15002
15003 SAVE_OPLINE();
15004 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15005
15006 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
15007 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
15008 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15009 UNDEF_RESULT();
15010 HANDLE_EXCEPTION();
15011 }
15012
15013 yield_from_try_again:
15014 if (Z_TYPE_P(val) == IS_ARRAY) {
15015 ZVAL_COPY_VALUE(&generator->values, val);
15016 if (Z_OPT_REFCOUNTED_P(val)) {
15017 Z_ADDREF_P(val);
15018 }
15019 Z_FE_POS(generator->values) = 0;
15020 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15021 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
15022 zend_class_entry *ce = Z_OBJCE_P(val);
15023 if (ce == zend_ce_generator) {
15024 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
15025
15026 Z_ADDREF_P(val);
15027 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15028
15029 if (UNEXPECTED(new_gen->execute_data == NULL)) {
15030 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
15031 zval_ptr_dtor(val);
15032 UNDEF_RESULT();
15033 HANDLE_EXCEPTION();
15034 } else if (Z_ISUNDEF(new_gen->retval)) {
15035 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
15036 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
15037 zval_ptr_dtor(val);
15038 UNDEF_RESULT();
15039 HANDLE_EXCEPTION();
15040 } else {
15041 zend_generator_yield_from(generator, new_gen);
15042 }
15043 } else {
15044 if (RETURN_VALUE_USED(opline)) {
15045 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
15046 }
15047 ZEND_VM_NEXT_OPCODE();
15048 }
15049 } else {
15050 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
15051 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15052
15053 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
15054 if (!EG(exception)) {
15055 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
15056 }
15057 UNDEF_RESULT();
15058 HANDLE_EXCEPTION();
15059 }
15060
15061 iter->index = 0;
15062 if (iter->funcs->rewind) {
15063 iter->funcs->rewind(iter);
15064 if (UNEXPECTED(EG(exception) != NULL)) {
15065 OBJ_RELEASE(&iter->std);
15066 UNDEF_RESULT();
15067 HANDLE_EXCEPTION();
15068 }
15069 }
15070
15071 ZVAL_OBJ(&generator->values, &iter->std);
15072 }
15073 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
15074 val = Z_REFVAL_P(val);
15075 goto yield_from_try_again;
15076 } else {
15077 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
15078 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15079 UNDEF_RESULT();
15080 HANDLE_EXCEPTION();
15081 }
15082
15083 /* This is the default return value
15084 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
15085 if (RETURN_VALUE_USED(opline)) {
15086 ZVAL_NULL(EX_VAR(opline->result.var));
15087 }
15088
15089 /* This generator has no send target (though the generator we delegate to might have one) */
15090 generator->send_target = NULL;
15091
15092 /* We increment to the next op, so we are at the correct position when the
15093 * generator is resumed. */
15094 ZEND_VM_INC_OPCODE();
15095
15096 /* The GOTO VM uses a local opline variable. We need to set the opline
15097 * variable in execute_data so we don't resume at an old position. */
15098 SAVE_OPLINE();
15099
15100 ZEND_VM_RETURN();
15101 }
15102
ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15103 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15104 {
15105 USE_OPLINE
15106 zval *value;
15107
15108 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15109 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15110 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15111 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15112 zval_ptr_dtor_str(value);
15113 }
15114 ZEND_VM_NEXT_OPCODE();
15115 } else {
15116 bool strict;
15117
15118 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
15119 value = Z_REFVAL_P(value);
15120 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15121 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15122 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15123 ZEND_VM_NEXT_OPCODE();
15124 }
15125 }
15126
15127 SAVE_OPLINE();
15128 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15129 value = ZVAL_UNDEFINED_OP1();
15130 }
15131 strict = EX_USES_STRICT_TYPES();
15132 do {
15133 if (EXPECTED(!strict)) {
15134 zend_string *str;
15135 zval tmp;
15136
15137 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
15138 zend_error(E_DEPRECATED,
15139 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
15140 ZVAL_LONG(EX_VAR(opline->result.var), 0);
15141 if (UNEXPECTED(EG(exception))) {
15142 HANDLE_EXCEPTION();
15143 }
15144 break;
15145 }
15146
15147 ZVAL_COPY(&tmp, value);
15148 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
15149 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
15150 zval_ptr_dtor(&tmp);
15151 break;
15152 }
15153 zval_ptr_dtor(&tmp);
15154 }
15155 if (!EG(exception)) {
15156 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
15157 }
15158 ZVAL_UNDEF(EX_VAR(opline->result.var));
15159 } while (0);
15160 }
15161 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15162 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15163 }
15164
ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15165 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15166 {
15167 USE_OPLINE
15168 zval *value;
15169 int result = 0;
15170
15171 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15172 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15173 type_check_resource:
15174 if (opline->extended_value != MAY_BE_RESOURCE
15175 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
15176 result = 1;
15177 }
15178 } else if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
15179 value = Z_REFVAL_P(value);
15180 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15181 goto type_check_resource;
15182 }
15183 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15184 result = ((1 << IS_NULL) & opline->extended_value) != 0;
15185 SAVE_OPLINE();
15186 ZVAL_UNDEFINED_OP1();
15187 if (UNEXPECTED(EG(exception))) {
15188 ZVAL_UNDEF(EX_VAR(opline->result.var));
15189 HANDLE_EXCEPTION();
15190 }
15191 }
15192 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15193 SAVE_OPLINE();
15194 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15195 ZEND_VM_SMART_BRANCH(result, 1);
15196 } else {
15197 ZEND_VM_SMART_BRANCH(result, 0);
15198 }
15199 }
15200
ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15201 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15202 {
15203 uint32_t fetch_type;
15204 zend_class_entry *called_scope, *scope;
15205 USE_OPLINE
15206
15207 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
15208 SAVE_OPLINE();
15209 zval *op = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15210 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
15211 ZVAL_DEREF(op);
15212 if (Z_TYPE_P(op) != IS_OBJECT) {
15213 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
15214 ZVAL_UNDEF(EX_VAR(opline->result.var));
15215 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15216 HANDLE_EXCEPTION();
15217 }
15218 }
15219
15220 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
15221 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15222 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15223 }
15224
15225 fetch_type = opline->op1.num;
15226 scope = EX(func)->op_array.scope;
15227 if (UNEXPECTED(scope == NULL)) {
15228 SAVE_OPLINE();
15229 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
15230 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
15231 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
15232 ZVAL_UNDEF(EX_VAR(opline->result.var));
15233 HANDLE_EXCEPTION();
15234 }
15235
15236 switch (fetch_type) {
15237 case ZEND_FETCH_CLASS_SELF:
15238 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
15239 break;
15240 case ZEND_FETCH_CLASS_PARENT:
15241 if (UNEXPECTED(scope->parent == NULL)) {
15242 SAVE_OPLINE();
15243 zend_throw_error(NULL,
15244 "Cannot use \"parent\" when current class scope has no parent");
15245 ZVAL_UNDEF(EX_VAR(opline->result.var));
15246 HANDLE_EXCEPTION();
15247 }
15248 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
15249 break;
15250 case ZEND_FETCH_CLASS_STATIC:
15251 if (Z_TYPE(EX(This)) == IS_OBJECT) {
15252 called_scope = Z_OBJCE(EX(This));
15253 } else {
15254 called_scope = Z_CE(EX(This));
15255 }
15256 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
15257 break;
15258 EMPTY_SWITCH_DEFAULT_CASE()
15259 }
15260 ZEND_VM_NEXT_OPCODE();
15261 }
15262
ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15263 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15264 {
15265 USE_OPLINE
15266 zval *op1, *op2;
15267
15268 SAVE_OPLINE();
15269 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15270 op2 = RT_CONSTANT(opline, opline->op2);
15271 div_function(EX_VAR(opline->result.var), op1, op2);
15272 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15273
15274 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15275 }
15276
ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15277 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15278 {
15279 USE_OPLINE
15280 zval *op1, *op2;
15281
15282 SAVE_OPLINE();
15283 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15284 op2 = RT_CONSTANT(opline, opline->op2);
15285 pow_function(EX_VAR(opline->result.var), op1, op2);
15286 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15287
15288 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15289 }
15290
ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15291 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15292 {
15293 USE_OPLINE
15294 zval *op1, *op2;
15295
15296 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15297 op2 = RT_CONSTANT(opline, opline->op2);
15298
15299 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
15300 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
15301 zend_string *op1_str = Z_STR_P(op1);
15302 zend_string *op2_str = Z_STR_P(op2);
15303 zend_string *str;
15304 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
15305
15306 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
15307 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
15308 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
15309 } else {
15310 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
15311 }
15312 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15313 zend_string_release_ex(op1_str, 0);
15314 }
15315 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
15316 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
15317 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
15318 } else {
15319 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
15320 }
15321 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15322 zend_string_release_ex(op2_str, 0);
15323 }
15324 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
15325 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
15326 size_t len = ZSTR_LEN(op1_str);
15327
15328 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
15329 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
15330 }
15331 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
15332 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15333 GC_ADD_FLAGS(str, flags);
15334 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15335 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15336 zend_string_release_ex(op2_str, 0);
15337 }
15338 } else {
15339 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
15340 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
15341 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15342 GC_ADD_FLAGS(str, flags);
15343 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15344 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15345 zend_string_release_ex(op1_str, 0);
15346 }
15347 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15348 zend_string_release_ex(op2_str, 0);
15349 }
15350 }
15351 ZEND_VM_NEXT_OPCODE();
15352 } else {
15353 SAVE_OPLINE();
15354
15355 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
15356 op1 = ZVAL_UNDEFINED_OP1();
15357 }
15358 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
15359 op2 = ZVAL_UNDEFINED_OP2();
15360 }
15361 concat_function(EX_VAR(opline->result.var), op1, op2);
15362 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15363
15364 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15365 }
15366 }
15367
ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15368 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15369 {
15370 USE_OPLINE
15371 zval *op1, *op2;
15372 double d1, d2;
15373
15374 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15375 op2 = RT_CONSTANT(opline, opline->op2);
15376 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15377 /* pass */
15378 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15379 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15380 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15381 is_equal_true:
15382 ZEND_VM_SMART_BRANCH_TRUE_NONE();
15383 } else {
15384 is_equal_false:
15385 ZEND_VM_SMART_BRANCH_FALSE_NONE();
15386 }
15387 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15388 d1 = (double)Z_LVAL_P(op1);
15389 d2 = Z_DVAL_P(op2);
15390 goto is_equal_double;
15391 }
15392 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15393 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15394 d1 = Z_DVAL_P(op1);
15395 d2 = Z_DVAL_P(op2);
15396 is_equal_double:
15397 if (d1 == d2) {
15398 goto is_equal_true;
15399 } else {
15400 goto is_equal_false;
15401 }
15402 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15403 d1 = Z_DVAL_P(op1);
15404 d2 = (double)Z_LVAL_P(op2);
15405 goto is_equal_double;
15406 }
15407 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15408 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15409 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15410 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15411 zval_ptr_dtor_str(op1);
15412 }
15413 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15414 zval_ptr_dtor_str(op2);
15415 }
15416 if (result) {
15417 goto is_equal_true;
15418 } else {
15419 goto is_equal_false;
15420 }
15421 }
15422 }
15423 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15424 }
15425
ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15426 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15427 {
15428 USE_OPLINE
15429 zval *op1, *op2;
15430 double d1, d2;
15431
15432 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15433 op2 = RT_CONSTANT(opline, opline->op2);
15434 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15435 /* pass */
15436 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15437 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15438 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15439 is_equal_true:
15440 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
15441 } else {
15442 is_equal_false:
15443 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
15444 }
15445 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15446 d1 = (double)Z_LVAL_P(op1);
15447 d2 = Z_DVAL_P(op2);
15448 goto is_equal_double;
15449 }
15450 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15451 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15452 d1 = Z_DVAL_P(op1);
15453 d2 = Z_DVAL_P(op2);
15454 is_equal_double:
15455 if (d1 == d2) {
15456 goto is_equal_true;
15457 } else {
15458 goto is_equal_false;
15459 }
15460 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15461 d1 = Z_DVAL_P(op1);
15462 d2 = (double)Z_LVAL_P(op2);
15463 goto is_equal_double;
15464 }
15465 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15466 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15467 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15468 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15469 zval_ptr_dtor_str(op1);
15470 }
15471 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15472 zval_ptr_dtor_str(op2);
15473 }
15474 if (result) {
15475 goto is_equal_true;
15476 } else {
15477 goto is_equal_false;
15478 }
15479 }
15480 }
15481 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15482 }
15483
ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15484 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15485 {
15486 USE_OPLINE
15487 zval *op1, *op2;
15488 double d1, d2;
15489
15490 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15491 op2 = RT_CONSTANT(opline, opline->op2);
15492 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15493 /* pass */
15494 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15495 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15496 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15497 is_equal_true:
15498 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
15499 } else {
15500 is_equal_false:
15501 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
15502 }
15503 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15504 d1 = (double)Z_LVAL_P(op1);
15505 d2 = Z_DVAL_P(op2);
15506 goto is_equal_double;
15507 }
15508 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15509 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15510 d1 = Z_DVAL_P(op1);
15511 d2 = Z_DVAL_P(op2);
15512 is_equal_double:
15513 if (d1 == d2) {
15514 goto is_equal_true;
15515 } else {
15516 goto is_equal_false;
15517 }
15518 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15519 d1 = Z_DVAL_P(op1);
15520 d2 = (double)Z_LVAL_P(op2);
15521 goto is_equal_double;
15522 }
15523 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15524 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15525 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15526 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15527 zval_ptr_dtor_str(op1);
15528 }
15529 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15530 zval_ptr_dtor_str(op2);
15531 }
15532 if (result) {
15533 goto is_equal_true;
15534 } else {
15535 goto is_equal_false;
15536 }
15537 }
15538 }
15539 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15540 }
15541
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15542 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15543 {
15544 USE_OPLINE
15545 zval *op1, *op2;
15546 double d1, d2;
15547
15548 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15549 op2 = RT_CONSTANT(opline, opline->op2);
15550 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15551 /* pass */
15552 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15553 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15554 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
15555 is_not_equal_true:
15556 ZEND_VM_SMART_BRANCH_TRUE_NONE();
15557 } else {
15558 is_not_equal_false:
15559 ZEND_VM_SMART_BRANCH_FALSE_NONE();
15560 }
15561 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15562 d1 = (double)Z_LVAL_P(op1);
15563 d2 = Z_DVAL_P(op2);
15564 goto is_not_equal_double;
15565 }
15566 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15567 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15568 d1 = Z_DVAL_P(op1);
15569 d2 = Z_DVAL_P(op2);
15570 is_not_equal_double:
15571 if (d1 != d2) {
15572 goto is_not_equal_true;
15573 } else {
15574 goto is_not_equal_false;
15575 }
15576 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15577 d1 = Z_DVAL_P(op1);
15578 d2 = (double)Z_LVAL_P(op2);
15579 goto is_not_equal_double;
15580 }
15581 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15582 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15583 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15584 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15585 zval_ptr_dtor_str(op1);
15586 }
15587 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15588 zval_ptr_dtor_str(op2);
15589 }
15590 if (!result) {
15591 goto is_not_equal_true;
15592 } else {
15593 goto is_not_equal_false;
15594 }
15595 }
15596 }
15597 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15598 }
15599
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15600 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15601 {
15602 USE_OPLINE
15603 zval *op1, *op2;
15604 double d1, d2;
15605
15606 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15607 op2 = RT_CONSTANT(opline, opline->op2);
15608 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15609 /* pass */
15610 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15611 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15612 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
15613 is_not_equal_true:
15614 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
15615 } else {
15616 is_not_equal_false:
15617 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
15618 }
15619 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15620 d1 = (double)Z_LVAL_P(op1);
15621 d2 = Z_DVAL_P(op2);
15622 goto is_not_equal_double;
15623 }
15624 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15625 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15626 d1 = Z_DVAL_P(op1);
15627 d2 = Z_DVAL_P(op2);
15628 is_not_equal_double:
15629 if (d1 != d2) {
15630 goto is_not_equal_true;
15631 } else {
15632 goto is_not_equal_false;
15633 }
15634 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15635 d1 = Z_DVAL_P(op1);
15636 d2 = (double)Z_LVAL_P(op2);
15637 goto is_not_equal_double;
15638 }
15639 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15640 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15641 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15642 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15643 zval_ptr_dtor_str(op1);
15644 }
15645 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15646 zval_ptr_dtor_str(op2);
15647 }
15648 if (!result) {
15649 goto is_not_equal_true;
15650 } else {
15651 goto is_not_equal_false;
15652 }
15653 }
15654 }
15655 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15656 }
15657
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15658 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15659 {
15660 USE_OPLINE
15661 zval *op1, *op2;
15662 double d1, d2;
15663
15664 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15665 op2 = RT_CONSTANT(opline, opline->op2);
15666 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15667 /* pass */
15668 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15669 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15670 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
15671 is_not_equal_true:
15672 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
15673 } else {
15674 is_not_equal_false:
15675 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
15676 }
15677 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15678 d1 = (double)Z_LVAL_P(op1);
15679 d2 = Z_DVAL_P(op2);
15680 goto is_not_equal_double;
15681 }
15682 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15683 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15684 d1 = Z_DVAL_P(op1);
15685 d2 = Z_DVAL_P(op2);
15686 is_not_equal_double:
15687 if (d1 != d2) {
15688 goto is_not_equal_true;
15689 } else {
15690 goto is_not_equal_false;
15691 }
15692 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15693 d1 = Z_DVAL_P(op1);
15694 d2 = (double)Z_LVAL_P(op2);
15695 goto is_not_equal_double;
15696 }
15697 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15698 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15699 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15700 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15701 zval_ptr_dtor_str(op1);
15702 }
15703 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15704 zval_ptr_dtor_str(op2);
15705 }
15706 if (!result) {
15707 goto is_not_equal_true;
15708 } else {
15709 goto is_not_equal_false;
15710 }
15711 }
15712 }
15713 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15714 }
15715
ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15716 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15717 {
15718 USE_OPLINE
15719 zval *op1, *op2;
15720
15721 SAVE_OPLINE();
15722 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15723 op2 = RT_CONSTANT(opline, opline->op2);
15724 compare_function(EX_VAR(opline->result.var), op1, op2);
15725 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15726
15727 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15728 }
15729
ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15730 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15731 {
15732 USE_OPLINE
15733 zval *op1, *op2;
15734
15735 SAVE_OPLINE();
15736 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15737 op2 = RT_CONSTANT(opline, opline->op2);
15738 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
15739 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15740
15741 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15742 }
15743
ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15744 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15745 {
15746 USE_OPLINE
15747 zval *container, *dim, *value;
15748
15749 SAVE_OPLINE();
15750 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15751 dim = RT_CONSTANT(opline, opline->op2);
15752 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
15753 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
15754 fetch_dim_r_array:
15755 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
15756 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
15757 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
15758 container = Z_REFVAL_P(container);
15759 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
15760 goto fetch_dim_r_array;
15761 } else {
15762 goto fetch_dim_r_slow;
15763 }
15764 } else {
15765 fetch_dim_r_slow:
15766 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
15767 dim++;
15768 }
15769 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
15770 }
15771 } else {
15772 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
15773 }
15774
15775 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15776 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15777 }
15778
ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15779 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15780 {
15781 USE_OPLINE
15782 zval *container;
15783
15784 SAVE_OPLINE();
15785 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15786 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
15787
15788 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15789 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15790 }
15791
ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15792 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15793 {
15794 USE_OPLINE
15795 zval *container;
15796 void **cache_slot = NULL;
15797
15798 SAVE_OPLINE();
15799 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15800
15801 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
15802 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
15803 do {
15804 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
15805 container = Z_REFVAL_P(container);
15806 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
15807 break;
15808 }
15809 }
15810 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
15811 ZVAL_UNDEFINED_OP1();
15812 }
15813 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
15814 ZVAL_NULL(EX_VAR(opline->result.var));
15815 goto fetch_obj_r_finish;
15816 } while (0);
15817 }
15818
15819 /* here we are sure we are dealing with an object */
15820 do {
15821 zend_object *zobj = Z_OBJ_P(container);
15822 zend_string *name, *tmp_name;
15823 zval *retval;
15824
15825 if (IS_CONST == IS_CONST) {
15826 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
15827
15828 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
15829 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
15830
15831 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
15832 retval = OBJ_PROP(zobj, prop_offset);
15833 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
15834 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15835 goto fetch_obj_r_copy;
15836 } else {
15837 fetch_obj_r_fast_copy:
15838 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
15839 ZEND_VM_NEXT_OPCODE();
15840 }
15841 }
15842 } else if (EXPECTED(zobj->properties != NULL)) {
15843 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
15844 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
15845 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
15846
15847 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
15848 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
15849
15850 if (EXPECTED(p->key == name) ||
15851 (EXPECTED(p->h == ZSTR_H(name)) &&
15852 EXPECTED(p->key != NULL) &&
15853 EXPECTED(zend_string_equal_content(p->key, name)))) {
15854 retval = &p->val;
15855 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15856 goto fetch_obj_r_copy;
15857 } else {
15858 goto fetch_obj_r_fast_copy;
15859 }
15860 }
15861 }
15862 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
15863 }
15864 retval = zend_hash_find_known_hash(zobj->properties, name);
15865 if (EXPECTED(retval)) {
15866 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
15867 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
15868 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15869 goto fetch_obj_r_copy;
15870 } else {
15871 goto fetch_obj_r_fast_copy;
15872 }
15873 }
15874 }
15875 }
15876 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
15877 } else {
15878 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
15879 if (UNEXPECTED(!name)) {
15880 ZVAL_UNDEF(EX_VAR(opline->result.var));
15881 break;
15882 }
15883 }
15884
15885 #if ZEND_DEBUG
15886 /* For non-standard object handlers, verify a declared property type in debug builds.
15887 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
15888 zend_property_info *prop_info = NULL;
15889 if (zobj->handlers->read_property != zend_std_read_property) {
15890 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
15891 }
15892 #endif
15893 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
15894 #if ZEND_DEBUG
15895 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
15896 && ZEND_TYPE_IS_SET(prop_info->type)) {
15897 ZVAL_OPT_DEREF(retval);
15898 zend_verify_property_type(prop_info, retval, /* strict */ true);
15899 }
15900 #endif
15901
15902 if (IS_CONST != IS_CONST) {
15903 zend_tmp_string_release(tmp_name);
15904 }
15905
15906 if (retval != EX_VAR(opline->result.var)) {
15907 fetch_obj_r_copy:
15908 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
15909 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
15910 zend_unwrap_reference(retval);
15911 }
15912 } while (0);
15913
15914 fetch_obj_r_finish:
15915
15916 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15917 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15918 }
15919
ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15920 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15921 {
15922 USE_OPLINE
15923 zval *container;
15924 void **cache_slot = NULL;
15925
15926 SAVE_OPLINE();
15927 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15928
15929 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
15930 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
15931 do {
15932 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
15933 container = Z_REFVAL_P(container);
15934 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
15935 break;
15936 }
15937 }
15938 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
15939 ZVAL_UNDEFINED_OP2();
15940 }
15941 ZVAL_NULL(EX_VAR(opline->result.var));
15942 goto fetch_obj_is_finish;
15943 } while (0);
15944 }
15945
15946 /* here we are sure we are dealing with an object */
15947 do {
15948 zend_object *zobj = Z_OBJ_P(container);
15949 zend_string *name, *tmp_name;
15950 zval *retval;
15951
15952 if (IS_CONST == IS_CONST) {
15953 cache_slot = CACHE_ADDR(opline->extended_value);
15954
15955 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
15956 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
15957
15958 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
15959 retval = OBJ_PROP(zobj, prop_offset);
15960 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
15961 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15962 goto fetch_obj_is_copy;
15963 } else {
15964 fetch_obj_is_fast_copy:
15965 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
15966 ZEND_VM_NEXT_OPCODE();
15967 }
15968 }
15969 } else if (EXPECTED(zobj->properties != NULL)) {
15970 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
15971 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
15972 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
15973
15974 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
15975 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
15976
15977 if (EXPECTED(p->key == name) ||
15978 (EXPECTED(p->h == ZSTR_H(name)) &&
15979 EXPECTED(p->key != NULL) &&
15980 EXPECTED(zend_string_equal_content(p->key, name)))) {
15981 retval = &p->val;
15982 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15983 goto fetch_obj_is_copy;
15984 } else {
15985 goto fetch_obj_is_fast_copy;
15986 }
15987 }
15988 }
15989 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
15990 }
15991 retval = zend_hash_find_known_hash(zobj->properties, name);
15992 if (EXPECTED(retval)) {
15993 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
15994 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
15995 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15996 goto fetch_obj_is_copy;
15997 } else {
15998 goto fetch_obj_is_fast_copy;
15999 }
16000 }
16001 }
16002 }
16003 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16004 } else {
16005 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
16006 if (UNEXPECTED(!name)) {
16007 ZVAL_UNDEF(EX_VAR(opline->result.var));
16008 break;
16009 }
16010 }
16011
16012 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
16013
16014 if (IS_CONST != IS_CONST) {
16015 zend_tmp_string_release(tmp_name);
16016 }
16017
16018 if (retval != EX_VAR(opline->result.var)) {
16019 fetch_obj_is_copy:
16020 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16021 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
16022 zend_unwrap_reference(retval);
16023 }
16024 } while (0);
16025
16026 fetch_obj_is_finish:
16027
16028 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16029 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16030 }
16031
ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16032 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16033 {
16034 USE_OPLINE
16035 zval *op1, *op2;
16036 zend_string *op1_str, *op2_str, *str;
16037
16038
16039 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16040 op2 = RT_CONSTANT(opline, opline->op2);
16041 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
16042 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
16043 zend_string *op1_str = Z_STR_P(op1);
16044 zend_string *op2_str = Z_STR_P(op2);
16045 zend_string *str;
16046 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
16047
16048 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16049 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
16050 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
16051 } else {
16052 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16053 }
16054 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16055 zend_string_release_ex(op1_str, 0);
16056 }
16057 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16058 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
16059 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
16060 } else {
16061 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16062 }
16063 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16064 zend_string_release_ex(op2_str, 0);
16065 }
16066 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
16067 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
16068 size_t len = ZSTR_LEN(op1_str);
16069
16070 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
16071 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16072 GC_ADD_FLAGS(str, flags);
16073 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16074 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16075 zend_string_release_ex(op2_str, 0);
16076 }
16077 } else {
16078 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16079 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16080 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16081 GC_ADD_FLAGS(str, flags);
16082 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16083 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16084 zend_string_release_ex(op1_str, 0);
16085 }
16086 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16087 zend_string_release_ex(op2_str, 0);
16088 }
16089 }
16090 ZEND_VM_NEXT_OPCODE();
16091 }
16092
16093 SAVE_OPLINE();
16094 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16095 op1_str = Z_STR_P(op1);
16096 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16097 op1_str = zend_string_copy(Z_STR_P(op1));
16098 } else {
16099 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
16100 ZVAL_UNDEFINED_OP1();
16101 }
16102 op1_str = zval_get_string_func(op1);
16103 }
16104 if (IS_CONST == IS_CONST) {
16105 op2_str = Z_STR_P(op2);
16106 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16107 op2_str = zend_string_copy(Z_STR_P(op2));
16108 } else {
16109 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
16110 ZVAL_UNDEFINED_OP2();
16111 }
16112 op2_str = zval_get_string_func(op2);
16113 }
16114 do {
16115 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16116 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16117 if (IS_CONST == IS_CONST) {
16118 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
16119 GC_ADDREF(op2_str);
16120 }
16121 }
16122 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16123 zend_string_release_ex(op1_str, 0);
16124 break;
16125 }
16126 }
16127 if (IS_CONST != IS_CONST) {
16128 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16129 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16130 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
16131 GC_ADDREF(op1_str);
16132 }
16133 }
16134 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16135 zend_string_release_ex(op2_str, 0);
16136 break;
16137 }
16138 }
16139 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16140 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16141 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16142
16143 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
16144 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16145 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16146 zend_string_release_ex(op1_str, 0);
16147 }
16148 if (IS_CONST != IS_CONST) {
16149 zend_string_release_ex(op2_str, 0);
16150 }
16151 } while (0);
16152 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16153
16154 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16155 }
16156
ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16157 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16158 {
16159 USE_OPLINE
16160 zval *function_name;
16161 zval *object;
16162 zend_function *fbc;
16163 zend_class_entry *called_scope;
16164 zend_object *obj;
16165 zend_execute_data *call;
16166 uint32_t call_info;
16167
16168 SAVE_OPLINE();
16169
16170 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16171
16172 if (IS_CONST != IS_CONST) {
16173 function_name = RT_CONSTANT(opline, opline->op2);
16174 }
16175
16176 if (IS_CONST != IS_CONST &&
16177 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
16178 do {
16179 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
16180 function_name = Z_REFVAL_P(function_name);
16181 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
16182 break;
16183 }
16184 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
16185 ZVAL_UNDEFINED_OP2();
16186 if (UNEXPECTED(EG(exception) != NULL)) {
16187 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16188 HANDLE_EXCEPTION();
16189 }
16190 }
16191 zend_throw_error(NULL, "Method name must be a string");
16192
16193 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16194 HANDLE_EXCEPTION();
16195 } while (0);
16196 }
16197
16198 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
16199 obj = Z_OBJ_P(object);
16200 } else {
16201 do {
16202 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16203 obj = Z_OBJ_P(object);
16204 } else {
16205 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
16206 zend_reference *ref = Z_REF_P(object);
16207
16208 object = &ref->val;
16209 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16210 obj = Z_OBJ_P(object);
16211 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
16212 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
16213 efree_size(ref, sizeof(zend_reference));
16214 } else {
16215 Z_ADDREF_P(object);
16216 }
16217 }
16218 break;
16219 }
16220 }
16221 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
16222 object = ZVAL_UNDEFINED_OP1();
16223 if (UNEXPECTED(EG(exception) != NULL)) {
16224 if (IS_CONST != IS_CONST) {
16225
16226 }
16227 HANDLE_EXCEPTION();
16228 }
16229 }
16230 if (IS_CONST == IS_CONST) {
16231 function_name = RT_CONSTANT(opline, opline->op2);
16232 }
16233 zend_invalid_method_call(object, function_name);
16234
16235 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16236 HANDLE_EXCEPTION();
16237 }
16238 } while (0);
16239 }
16240
16241 called_scope = obj->ce;
16242
16243 if (IS_CONST == IS_CONST &&
16244 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
16245 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
16246 } else {
16247 zend_object *orig_obj = obj;
16248
16249 if (IS_CONST == IS_CONST) {
16250 function_name = RT_CONSTANT(opline, opline->op2);
16251 }
16252
16253 /* First, locate the function. */
16254 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
16255 if (UNEXPECTED(fbc == NULL)) {
16256 if (EXPECTED(!EG(exception))) {
16257 zend_undefined_method(obj->ce, Z_STR_P(function_name));
16258 }
16259
16260 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
16261 zend_objects_store_del(orig_obj);
16262 }
16263 HANDLE_EXCEPTION();
16264 }
16265 if (IS_CONST == IS_CONST &&
16266 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
16267 EXPECTED(obj == orig_obj)) {
16268 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
16269 }
16270 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
16271 GC_ADDREF(obj); /* For $this pointer */
16272 if (GC_DELREF(orig_obj) == 0) {
16273 zend_objects_store_del(orig_obj);
16274 }
16275 }
16276 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
16277 init_func_run_time_cache(&fbc->op_array);
16278 }
16279 }
16280
16281 if (IS_CONST != IS_CONST) {
16282
16283 }
16284
16285 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
16286 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
16287 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
16288 zend_objects_store_del(obj);
16289 if (UNEXPECTED(EG(exception))) {
16290 HANDLE_EXCEPTION();
16291 }
16292 }
16293 /* call static method */
16294 obj = (zend_object*)called_scope;
16295 call_info = ZEND_CALL_NESTED_FUNCTION;
16296 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
16297 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
16298 GC_ADDREF(obj); /* For $this pointer */
16299 }
16300 /* CV may be changed indirectly (e.g. when it's a reference) */
16301 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
16302 }
16303
16304 call = zend_vm_stack_push_call_frame(call_info,
16305 fbc, opline->extended_value, obj);
16306 call->prev_execute_data = EX(call);
16307 EX(call) = call;
16308
16309 ZEND_VM_NEXT_OPCODE();
16310 }
16311
ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16312 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16313 {
16314 USE_OPLINE
16315 zval *value, *arg;
16316
16317 if (IS_CONST == IS_CONST) {
16318 SAVE_OPLINE();
16319 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16320 uint32_t arg_num;
16321 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
16322 if (UNEXPECTED(!arg)) {
16323 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16324 HANDLE_EXCEPTION();
16325 }
16326 } else {
16327 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
16328 }
16329
16330 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16331 ZVAL_COPY_VALUE(arg, value);
16332 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16333 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
16334 Z_ADDREF_P(arg);
16335 }
16336 }
16337 ZEND_VM_NEXT_OPCODE();
16338 }
16339
ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16340 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16341 {
16342 USE_OPLINE
16343 zval *op1, *op2;
16344 double d1, d2;
16345
16346 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16347 op2 = RT_CONSTANT(opline, opline->op2);
16348 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16349 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16350 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16351 case_true:
16352 ZEND_VM_SMART_BRANCH_TRUE();
16353 } else {
16354 case_false:
16355 ZEND_VM_SMART_BRANCH_FALSE();
16356 }
16357 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16358 d1 = (double)Z_LVAL_P(op1);
16359 d2 = Z_DVAL_P(op2);
16360 goto case_double;
16361 }
16362 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16363 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16364 d1 = Z_DVAL_P(op1);
16365 d2 = Z_DVAL_P(op2);
16366 case_double:
16367 if (d1 == d2) {
16368 goto case_true;
16369 } else {
16370 goto case_false;
16371 }
16372 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16373 d1 = Z_DVAL_P(op1);
16374 d2 = (double)Z_LVAL_P(op2);
16375 goto case_double;
16376 }
16377 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16378 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16379 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16380
16381 if (result) {
16382 goto case_true;
16383 } else {
16384 goto case_false;
16385 }
16386 }
16387 }
16388 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16389 }
16390
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16391 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16392 {
16393 USE_OPLINE
16394 zval *container;
16395 bool result;
16396 zend_ulong hval;
16397 zval *offset;
16398
16399 SAVE_OPLINE();
16400 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16401 offset = RT_CONSTANT(opline, opline->op2);
16402
16403 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16404 HashTable *ht;
16405 zval *value;
16406 zend_string *str;
16407
16408 isset_dim_obj_array:
16409 ht = Z_ARRVAL_P(container);
16410 isset_again:
16411 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
16412 str = Z_STR_P(offset);
16413 if (IS_CONST != IS_CONST) {
16414 if (ZEND_HANDLE_NUMERIC(str, hval)) {
16415 goto num_index_prop;
16416 }
16417 }
16418 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
16419 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
16420 hval = Z_LVAL_P(offset);
16421 num_index_prop:
16422 value = zend_hash_index_find(ht, hval);
16423 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
16424 offset = Z_REFVAL_P(offset);
16425 goto isset_again;
16426 } else {
16427 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
16428 if (UNEXPECTED(EG(exception))) {
16429 result = 0;
16430 goto isset_dim_obj_exit;
16431 }
16432 }
16433
16434 if (!(opline->extended_value & ZEND_ISEMPTY)) {
16435 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
16436 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
16437 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
16438
16439 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
16440 /* avoid exception check */
16441
16442 ZEND_VM_SMART_BRANCH(result, 0);
16443 }
16444 } else {
16445 result = (value == NULL || !i_zend_is_true(value));
16446 }
16447 goto isset_dim_obj_exit;
16448 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
16449 container = Z_REFVAL_P(container);
16450 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16451 goto isset_dim_obj_array;
16452 }
16453 }
16454
16455 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
16456 offset++;
16457 }
16458 if (!(opline->extended_value & ZEND_ISEMPTY)) {
16459 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
16460 } else {
16461 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
16462 }
16463
16464 isset_dim_obj_exit:
16465
16466 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16467 ZEND_VM_SMART_BRANCH(result, 1);
16468 }
16469
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16470 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16471 {
16472 USE_OPLINE
16473 zval *container;
16474 int result;
16475 zval *offset;
16476 zend_string *name, *tmp_name;
16477
16478 SAVE_OPLINE();
16479 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16480 offset = RT_CONSTANT(opline, opline->op2);
16481
16482 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16483 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16484 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16485 container = Z_REFVAL_P(container);
16486 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
16487 result = (opline->extended_value & ZEND_ISEMPTY);
16488 goto isset_object_finish;
16489 }
16490 } else {
16491 result = (opline->extended_value & ZEND_ISEMPTY);
16492 goto isset_object_finish;
16493 }
16494 }
16495
16496 if (IS_CONST == IS_CONST) {
16497 name = Z_STR_P(offset);
16498 } else {
16499 name = zval_try_get_tmp_string(offset, &tmp_name);
16500 if (UNEXPECTED(!name)) {
16501 result = 0;
16502 goto isset_object_finish;
16503 }
16504 }
16505
16506 result =
16507 (opline->extended_value & ZEND_ISEMPTY) ^
16508 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));
16509
16510 if (IS_CONST != IS_CONST) {
16511 zend_tmp_string_release(tmp_name);
16512 }
16513
16514 isset_object_finish:
16515
16516 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16517 ZEND_VM_SMART_BRANCH(result, 1);
16518 }
16519
ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16520 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16521 {
16522 USE_OPLINE
16523
16524 zval *key, *subject;
16525 HashTable *ht;
16526 bool result;
16527
16528 SAVE_OPLINE();
16529
16530 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16531 subject = RT_CONSTANT(opline, opline->op2);
16532
16533 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
16534 array_key_exists_array:
16535 ht = Z_ARRVAL_P(subject);
16536 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
16537 } else {
16538 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
16539 subject = Z_REFVAL_P(subject);
16540 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
16541 goto array_key_exists_array;
16542 }
16543 }
16544 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
16545 result = 0;
16546 }
16547
16548 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16549 ZEND_VM_SMART_BRANCH(result, 1);
16550 }
16551
16552 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16553 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16554 {
16555 USE_OPLINE
16556 zval *expr;
16557 bool result;
16558
16559 SAVE_OPLINE();
16560 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16561
16562 try_instanceof:
16563 if (Z_TYPE_P(expr) == IS_OBJECT) {
16564 zend_class_entry *ce;
16565
16566 if (IS_CONST == IS_CONST) {
16567 ce = CACHED_PTR(opline->extended_value);
16568 if (UNEXPECTED(ce == NULL)) {
16569 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);
16570 if (EXPECTED(ce)) {
16571 CACHE_PTR(opline->extended_value, ce);
16572 }
16573 }
16574 } else if (IS_CONST == IS_UNUSED) {
16575 ce = zend_fetch_class(NULL, opline->op2.num);
16576 if (UNEXPECTED(ce == NULL)) {
16577 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16578 ZVAL_UNDEF(EX_VAR(opline->result.var));
16579 HANDLE_EXCEPTION();
16580 }
16581 } else {
16582 ce = Z_CE_P(EX_VAR(opline->op2.var));
16583 }
16584 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
16585 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
16586 expr = Z_REFVAL_P(expr);
16587 goto try_instanceof;
16588 } else {
16589 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
16590 ZVAL_UNDEFINED_OP1();
16591 }
16592 result = 0;
16593 }
16594 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16595 ZEND_VM_SMART_BRANCH(result, 1);
16596 }
16597
ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16598 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16599 {
16600 USE_OPLINE
16601 zval *container, *dim, *value;
16602 zend_long offset;
16603 HashTable *ht;
16604
16605 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16606 dim = RT_CONSTANT(opline, opline->op2);
16607 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16608 fetch_dim_r_index_array:
16609 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
16610 offset = Z_LVAL_P(dim);
16611 } else {
16612 SAVE_OPLINE();
16613 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
16614 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16615 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16616 }
16617 ht = Z_ARRVAL_P(container);
16618 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
16619 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
16620 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16621 SAVE_OPLINE();
16622 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16623 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16624 } else {
16625 ZEND_VM_NEXT_OPCODE();
16626 }
16627 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
16628 container = Z_REFVAL_P(container);
16629 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16630 goto fetch_dim_r_index_array;
16631 } else {
16632 goto fetch_dim_r_index_slow;
16633 }
16634 } else {
16635 fetch_dim_r_index_slow:
16636 SAVE_OPLINE();
16637 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
16638 dim++;
16639 }
16640 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
16641 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16642 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16643 }
16644
16645 fetch_dim_r_index_undef:
16646 ZVAL_NULL(EX_VAR(opline->result.var));
16647 SAVE_OPLINE();
16648 zend_undefined_offset(offset);
16649 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16650 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16651 }
16652
ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16653 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16654 {
16655 USE_OPLINE
16656 zval *container, *dim, *value;
16657 zend_long offset;
16658 HashTable *ht;
16659
16660 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16661 dim = EX_VAR(opline->op2.var);
16662 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16663 fetch_dim_r_index_array:
16664 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
16665 offset = Z_LVAL_P(dim);
16666 } else {
16667 SAVE_OPLINE();
16668 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
16669 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16670 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16671 }
16672 ht = Z_ARRVAL_P(container);
16673 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
16674 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
16675 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16676 SAVE_OPLINE();
16677 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16678 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16679 } else {
16680 ZEND_VM_NEXT_OPCODE();
16681 }
16682 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
16683 container = Z_REFVAL_P(container);
16684 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16685 goto fetch_dim_r_index_array;
16686 } else {
16687 goto fetch_dim_r_index_slow;
16688 }
16689 } else {
16690 fetch_dim_r_index_slow:
16691 SAVE_OPLINE();
16692 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
16693 dim++;
16694 }
16695 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
16696 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16697 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16698 }
16699
16700 fetch_dim_r_index_undef:
16701 ZVAL_NULL(EX_VAR(opline->result.var));
16702 SAVE_OPLINE();
16703 zend_undefined_offset(offset);
16704 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16705 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16706 }
16707
ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16708 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16709 {
16710 USE_OPLINE
16711 zval *op1, *op2;
16712
16713 SAVE_OPLINE();
16714 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16715 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16716 div_function(EX_VAR(opline->result.var), op1, op2);
16717 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16718 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
16719 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16720 }
16721
ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16722 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16723 {
16724 USE_OPLINE
16725 zval *op1, *op2;
16726
16727 SAVE_OPLINE();
16728 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16729 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16730 pow_function(EX_VAR(opline->result.var), op1, op2);
16731 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16732 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
16733 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16734 }
16735
ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16736 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16737 {
16738 USE_OPLINE
16739 zval *op1, *op2;
16740
16741 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16742 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16743
16744 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
16745 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
16746 zend_string *op1_str = Z_STR_P(op1);
16747 zend_string *op2_str = Z_STR_P(op2);
16748 zend_string *str;
16749 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
16750
16751 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16752 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
16753 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
16754 } else {
16755 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16756 }
16757 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16758 zend_string_release_ex(op1_str, 0);
16759 }
16760 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16761 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
16762 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
16763 } else {
16764 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16765 }
16766 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16767 zend_string_release_ex(op2_str, 0);
16768 }
16769 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
16770 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
16771 size_t len = ZSTR_LEN(op1_str);
16772
16773 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
16774 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
16775 }
16776 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
16777 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16778 GC_ADD_FLAGS(str, flags);
16779 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16780 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16781 zend_string_release_ex(op2_str, 0);
16782 }
16783 } else {
16784 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16785 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16786 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16787 GC_ADD_FLAGS(str, flags);
16788 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16789 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16790 zend_string_release_ex(op1_str, 0);
16791 }
16792 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16793 zend_string_release_ex(op2_str, 0);
16794 }
16795 }
16796 ZEND_VM_NEXT_OPCODE();
16797 } else {
16798 SAVE_OPLINE();
16799
16800 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
16801 op1 = ZVAL_UNDEFINED_OP1();
16802 }
16803 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
16804 op2 = ZVAL_UNDEFINED_OP2();
16805 }
16806 concat_function(EX_VAR(opline->result.var), op1, op2);
16807 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16808 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
16809 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16810 }
16811 }
16812
ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16813 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16814 {
16815 USE_OPLINE
16816 zval *op1, *op2;
16817 double d1, d2;
16818
16819 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16820 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16821 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
16822 /* pass */
16823 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16824 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16825 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16826 is_equal_true:
16827 ZEND_VM_SMART_BRANCH_TRUE_NONE();
16828 } else {
16829 is_equal_false:
16830 ZEND_VM_SMART_BRANCH_FALSE_NONE();
16831 }
16832 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16833 d1 = (double)Z_LVAL_P(op1);
16834 d2 = Z_DVAL_P(op2);
16835 goto is_equal_double;
16836 }
16837 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16838 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16839 d1 = Z_DVAL_P(op1);
16840 d2 = Z_DVAL_P(op2);
16841 is_equal_double:
16842 if (d1 == d2) {
16843 goto is_equal_true;
16844 } else {
16845 goto is_equal_false;
16846 }
16847 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16848 d1 = Z_DVAL_P(op1);
16849 d2 = (double)Z_LVAL_P(op2);
16850 goto is_equal_double;
16851 }
16852 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16853 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16854 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16855 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16856 zval_ptr_dtor_str(op1);
16857 }
16858 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16859 zval_ptr_dtor_str(op2);
16860 }
16861 if (result) {
16862 goto is_equal_true;
16863 } else {
16864 goto is_equal_false;
16865 }
16866 }
16867 }
16868 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16869 }
16870
ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16871 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16872 {
16873 USE_OPLINE
16874 zval *op1, *op2;
16875 double d1, d2;
16876
16877 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16878 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16879 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
16880 /* pass */
16881 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16882 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16883 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16884 is_equal_true:
16885 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
16886 } else {
16887 is_equal_false:
16888 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
16889 }
16890 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16891 d1 = (double)Z_LVAL_P(op1);
16892 d2 = Z_DVAL_P(op2);
16893 goto is_equal_double;
16894 }
16895 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16896 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16897 d1 = Z_DVAL_P(op1);
16898 d2 = Z_DVAL_P(op2);
16899 is_equal_double:
16900 if (d1 == d2) {
16901 goto is_equal_true;
16902 } else {
16903 goto is_equal_false;
16904 }
16905 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16906 d1 = Z_DVAL_P(op1);
16907 d2 = (double)Z_LVAL_P(op2);
16908 goto is_equal_double;
16909 }
16910 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16911 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16912 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16913 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16914 zval_ptr_dtor_str(op1);
16915 }
16916 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16917 zval_ptr_dtor_str(op2);
16918 }
16919 if (result) {
16920 goto is_equal_true;
16921 } else {
16922 goto is_equal_false;
16923 }
16924 }
16925 }
16926 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16927 }
16928
ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16929 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16930 {
16931 USE_OPLINE
16932 zval *op1, *op2;
16933 double d1, d2;
16934
16935 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16936 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16937 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
16938 /* pass */
16939 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16940 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16941 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16942 is_equal_true:
16943 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
16944 } else {
16945 is_equal_false:
16946 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
16947 }
16948 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16949 d1 = (double)Z_LVAL_P(op1);
16950 d2 = Z_DVAL_P(op2);
16951 goto is_equal_double;
16952 }
16953 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16954 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16955 d1 = Z_DVAL_P(op1);
16956 d2 = Z_DVAL_P(op2);
16957 is_equal_double:
16958 if (d1 == d2) {
16959 goto is_equal_true;
16960 } else {
16961 goto is_equal_false;
16962 }
16963 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16964 d1 = Z_DVAL_P(op1);
16965 d2 = (double)Z_LVAL_P(op2);
16966 goto is_equal_double;
16967 }
16968 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16969 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16970 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16971 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16972 zval_ptr_dtor_str(op1);
16973 }
16974 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16975 zval_ptr_dtor_str(op2);
16976 }
16977 if (result) {
16978 goto is_equal_true;
16979 } else {
16980 goto is_equal_false;
16981 }
16982 }
16983 }
16984 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16985 }
16986
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16987 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16988 {
16989 USE_OPLINE
16990 zval *op1, *op2;
16991 double d1, d2;
16992
16993 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16994 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16995 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
16996 /* pass */
16997 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16998 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16999 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17000 is_not_equal_true:
17001 ZEND_VM_SMART_BRANCH_TRUE_NONE();
17002 } else {
17003 is_not_equal_false:
17004 ZEND_VM_SMART_BRANCH_FALSE_NONE();
17005 }
17006 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17007 d1 = (double)Z_LVAL_P(op1);
17008 d2 = Z_DVAL_P(op2);
17009 goto is_not_equal_double;
17010 }
17011 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17012 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17013 d1 = Z_DVAL_P(op1);
17014 d2 = Z_DVAL_P(op2);
17015 is_not_equal_double:
17016 if (d1 != d2) {
17017 goto is_not_equal_true;
17018 } else {
17019 goto is_not_equal_false;
17020 }
17021 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17022 d1 = Z_DVAL_P(op1);
17023 d2 = (double)Z_LVAL_P(op2);
17024 goto is_not_equal_double;
17025 }
17026 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17027 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17028 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17029 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17030 zval_ptr_dtor_str(op1);
17031 }
17032 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17033 zval_ptr_dtor_str(op2);
17034 }
17035 if (!result) {
17036 goto is_not_equal_true;
17037 } else {
17038 goto is_not_equal_false;
17039 }
17040 }
17041 }
17042 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17043 }
17044
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17045 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17046 {
17047 USE_OPLINE
17048 zval *op1, *op2;
17049 double d1, d2;
17050
17051 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17052 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17053 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17054 /* pass */
17055 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17056 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17057 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17058 is_not_equal_true:
17059 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
17060 } else {
17061 is_not_equal_false:
17062 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
17063 }
17064 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17065 d1 = (double)Z_LVAL_P(op1);
17066 d2 = Z_DVAL_P(op2);
17067 goto is_not_equal_double;
17068 }
17069 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17070 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17071 d1 = Z_DVAL_P(op1);
17072 d2 = Z_DVAL_P(op2);
17073 is_not_equal_double:
17074 if (d1 != d2) {
17075 goto is_not_equal_true;
17076 } else {
17077 goto is_not_equal_false;
17078 }
17079 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17080 d1 = Z_DVAL_P(op1);
17081 d2 = (double)Z_LVAL_P(op2);
17082 goto is_not_equal_double;
17083 }
17084 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17085 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17086 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17087 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17088 zval_ptr_dtor_str(op1);
17089 }
17090 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17091 zval_ptr_dtor_str(op2);
17092 }
17093 if (!result) {
17094 goto is_not_equal_true;
17095 } else {
17096 goto is_not_equal_false;
17097 }
17098 }
17099 }
17100 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17101 }
17102
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17103 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17104 {
17105 USE_OPLINE
17106 zval *op1, *op2;
17107 double d1, d2;
17108
17109 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17110 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17111 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17112 /* pass */
17113 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17114 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17115 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17116 is_not_equal_true:
17117 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
17118 } else {
17119 is_not_equal_false:
17120 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
17121 }
17122 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17123 d1 = (double)Z_LVAL_P(op1);
17124 d2 = Z_DVAL_P(op2);
17125 goto is_not_equal_double;
17126 }
17127 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17128 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17129 d1 = Z_DVAL_P(op1);
17130 d2 = Z_DVAL_P(op2);
17131 is_not_equal_double:
17132 if (d1 != d2) {
17133 goto is_not_equal_true;
17134 } else {
17135 goto is_not_equal_false;
17136 }
17137 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17138 d1 = Z_DVAL_P(op1);
17139 d2 = (double)Z_LVAL_P(op2);
17140 goto is_not_equal_double;
17141 }
17142 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17143 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17144 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17145 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17146 zval_ptr_dtor_str(op1);
17147 }
17148 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17149 zval_ptr_dtor_str(op2);
17150 }
17151 if (!result) {
17152 goto is_not_equal_true;
17153 } else {
17154 goto is_not_equal_false;
17155 }
17156 }
17157 }
17158 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17159 }
17160
ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17161 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17162 {
17163 USE_OPLINE
17164 zval *op1, *op2;
17165
17166 SAVE_OPLINE();
17167 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17168 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17169 compare_function(EX_VAR(opline->result.var), op1, op2);
17170 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17171 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17172 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17173 }
17174
ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17175 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17176 {
17177 USE_OPLINE
17178 zval *op1, *op2;
17179
17180 SAVE_OPLINE();
17181 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17182 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17183 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
17184 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17185 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17186 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17187 }
17188
ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17189 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17190 {
17191 USE_OPLINE
17192 zval *container, *dim, *value;
17193
17194 SAVE_OPLINE();
17195 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17196 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17197 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17198 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17199 fetch_dim_r_array:
17200 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
17201 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17202 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17203 container = Z_REFVAL_P(container);
17204 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17205 goto fetch_dim_r_array;
17206 } else {
17207 goto fetch_dim_r_slow;
17208 }
17209 } else {
17210 fetch_dim_r_slow:
17211 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17212 dim++;
17213 }
17214 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17215 }
17216 } else {
17217 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
17218 }
17219 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17220 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17221 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17222 }
17223
ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17224 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17225 {
17226 USE_OPLINE
17227 zval *container;
17228
17229 SAVE_OPLINE();
17230 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17231 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);
17232 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17233 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17234 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17235 }
17236
ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17237 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17238 {
17239 USE_OPLINE
17240 zval *container;
17241 void **cache_slot = NULL;
17242
17243 SAVE_OPLINE();
17244 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17245
17246 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17247 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17248 do {
17249 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17250 container = Z_REFVAL_P(container);
17251 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
17252 break;
17253 }
17254 }
17255 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
17256 ZVAL_UNDEFINED_OP1();
17257 }
17258 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17259 ZVAL_NULL(EX_VAR(opline->result.var));
17260 goto fetch_obj_r_finish;
17261 } while (0);
17262 }
17263
17264 /* here we are sure we are dealing with an object */
17265 do {
17266 zend_object *zobj = Z_OBJ_P(container);
17267 zend_string *name, *tmp_name;
17268 zval *retval;
17269
17270 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17271 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
17272
17273 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
17274 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
17275
17276 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
17277 retval = OBJ_PROP(zobj, prop_offset);
17278 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
17279 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17280 goto fetch_obj_r_copy;
17281 } else {
17282 fetch_obj_r_fast_copy:
17283 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17284 ZEND_VM_NEXT_OPCODE();
17285 }
17286 }
17287 } else if (EXPECTED(zobj->properties != NULL)) {
17288 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17289 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
17290 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
17291
17292 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
17293 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
17294
17295 if (EXPECTED(p->key == name) ||
17296 (EXPECTED(p->h == ZSTR_H(name)) &&
17297 EXPECTED(p->key != NULL) &&
17298 EXPECTED(zend_string_equal_content(p->key, name)))) {
17299 retval = &p->val;
17300 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17301 goto fetch_obj_r_copy;
17302 } else {
17303 goto fetch_obj_r_fast_copy;
17304 }
17305 }
17306 }
17307 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
17308 }
17309 retval = zend_hash_find_known_hash(zobj->properties, name);
17310 if (EXPECTED(retval)) {
17311 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
17312 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
17313 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17314 goto fetch_obj_r_copy;
17315 } else {
17316 goto fetch_obj_r_fast_copy;
17317 }
17318 }
17319 }
17320 }
17321 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17322 } else {
17323 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
17324 if (UNEXPECTED(!name)) {
17325 ZVAL_UNDEF(EX_VAR(opline->result.var));
17326 break;
17327 }
17328 }
17329
17330 #if ZEND_DEBUG
17331 /* For non-standard object handlers, verify a declared property type in debug builds.
17332 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
17333 zend_property_info *prop_info = NULL;
17334 if (zobj->handlers->read_property != zend_std_read_property) {
17335 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
17336 }
17337 #endif
17338 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
17339 #if ZEND_DEBUG
17340 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
17341 && ZEND_TYPE_IS_SET(prop_info->type)) {
17342 ZVAL_OPT_DEREF(retval);
17343 zend_verify_property_type(prop_info, retval, /* strict */ true);
17344 }
17345 #endif
17346
17347 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17348 zend_tmp_string_release(tmp_name);
17349 }
17350
17351 if (retval != EX_VAR(opline->result.var)) {
17352 fetch_obj_r_copy:
17353 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17354 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
17355 zend_unwrap_reference(retval);
17356 }
17357 } while (0);
17358
17359 fetch_obj_r_finish:
17360 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17361 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17362 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17363 }
17364
ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17365 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17366 {
17367 USE_OPLINE
17368 zval *container;
17369 void **cache_slot = NULL;
17370
17371 SAVE_OPLINE();
17372 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17373
17374 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17375 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17376 do {
17377 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17378 container = Z_REFVAL_P(container);
17379 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
17380 break;
17381 }
17382 }
17383 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
17384 ZVAL_UNDEFINED_OP2();
17385 }
17386 ZVAL_NULL(EX_VAR(opline->result.var));
17387 goto fetch_obj_is_finish;
17388 } while (0);
17389 }
17390
17391 /* here we are sure we are dealing with an object */
17392 do {
17393 zend_object *zobj = Z_OBJ_P(container);
17394 zend_string *name, *tmp_name;
17395 zval *retval;
17396
17397 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17398 cache_slot = CACHE_ADDR(opline->extended_value);
17399
17400 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
17401 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
17402
17403 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
17404 retval = OBJ_PROP(zobj, prop_offset);
17405 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
17406 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17407 goto fetch_obj_is_copy;
17408 } else {
17409 fetch_obj_is_fast_copy:
17410 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17411 ZEND_VM_NEXT_OPCODE();
17412 }
17413 }
17414 } else if (EXPECTED(zobj->properties != NULL)) {
17415 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17416 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
17417 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
17418
17419 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
17420 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
17421
17422 if (EXPECTED(p->key == name) ||
17423 (EXPECTED(p->h == ZSTR_H(name)) &&
17424 EXPECTED(p->key != NULL) &&
17425 EXPECTED(zend_string_equal_content(p->key, name)))) {
17426 retval = &p->val;
17427 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17428 goto fetch_obj_is_copy;
17429 } else {
17430 goto fetch_obj_is_fast_copy;
17431 }
17432 }
17433 }
17434 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
17435 }
17436 retval = zend_hash_find_known_hash(zobj->properties, name);
17437 if (EXPECTED(retval)) {
17438 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
17439 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
17440 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17441 goto fetch_obj_is_copy;
17442 } else {
17443 goto fetch_obj_is_fast_copy;
17444 }
17445 }
17446 }
17447 }
17448 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17449 } else {
17450 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
17451 if (UNEXPECTED(!name)) {
17452 ZVAL_UNDEF(EX_VAR(opline->result.var));
17453 break;
17454 }
17455 }
17456
17457 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
17458
17459 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17460 zend_tmp_string_release(tmp_name);
17461 }
17462
17463 if (retval != EX_VAR(opline->result.var)) {
17464 fetch_obj_is_copy:
17465 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17466 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
17467 zend_unwrap_reference(retval);
17468 }
17469 } while (0);
17470
17471 fetch_obj_is_finish:
17472 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17473 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17474 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17475 }
17476
ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17477 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17478 {
17479 USE_OPLINE
17480 zval *op1, *op2;
17481 zend_string *op1_str, *op2_str, *str;
17482
17483
17484 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17485 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17486 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
17487 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
17488 zend_string *op1_str = Z_STR_P(op1);
17489 zend_string *op2_str = Z_STR_P(op2);
17490 zend_string *str;
17491 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
17492
17493 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
17494 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17495 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
17496 } else {
17497 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
17498 }
17499 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17500 zend_string_release_ex(op1_str, 0);
17501 }
17502 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
17503 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17504 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
17505 } else {
17506 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
17507 }
17508 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17509 zend_string_release_ex(op2_str, 0);
17510 }
17511 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
17512 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
17513 size_t len = ZSTR_LEN(op1_str);
17514
17515 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
17516 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17517 GC_ADD_FLAGS(str, flags);
17518 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17519 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17520 zend_string_release_ex(op2_str, 0);
17521 }
17522 } else {
17523 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
17524 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
17525 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17526 GC_ADD_FLAGS(str, flags);
17527 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17528 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17529 zend_string_release_ex(op1_str, 0);
17530 }
17531 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17532 zend_string_release_ex(op2_str, 0);
17533 }
17534 }
17535 ZEND_VM_NEXT_OPCODE();
17536 }
17537
17538 SAVE_OPLINE();
17539 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17540 op1_str = Z_STR_P(op1);
17541 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17542 op1_str = zend_string_copy(Z_STR_P(op1));
17543 } else {
17544 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
17545 ZVAL_UNDEFINED_OP1();
17546 }
17547 op1_str = zval_get_string_func(op1);
17548 }
17549 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17550 op2_str = Z_STR_P(op2);
17551 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17552 op2_str = zend_string_copy(Z_STR_P(op2));
17553 } else {
17554 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
17555 ZVAL_UNDEFINED_OP2();
17556 }
17557 op2_str = zval_get_string_func(op2);
17558 }
17559 do {
17560 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17561 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
17562 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17563 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
17564 GC_ADDREF(op2_str);
17565 }
17566 }
17567 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
17568 zend_string_release_ex(op1_str, 0);
17569 break;
17570 }
17571 }
17572 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17573 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
17574 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17575 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
17576 GC_ADDREF(op1_str);
17577 }
17578 }
17579 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
17580 zend_string_release_ex(op2_str, 0);
17581 break;
17582 }
17583 }
17584 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
17585 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
17586 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17587
17588 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
17589 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17590 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17591 zend_string_release_ex(op1_str, 0);
17592 }
17593 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17594 zend_string_release_ex(op2_str, 0);
17595 }
17596 } while (0);
17597 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17598 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17599 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17600 }
17601
ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17602 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17603 {
17604 USE_OPLINE
17605 zval *function_name;
17606 zval *object;
17607 zend_function *fbc;
17608 zend_class_entry *called_scope;
17609 zend_object *obj;
17610 zend_execute_data *call;
17611 uint32_t call_info;
17612
17613 SAVE_OPLINE();
17614
17615 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17616
17617 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17618 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17619 }
17620
17621 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
17622 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
17623 do {
17624 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
17625 function_name = Z_REFVAL_P(function_name);
17626 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
17627 break;
17628 }
17629 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
17630 ZVAL_UNDEFINED_OP2();
17631 if (UNEXPECTED(EG(exception) != NULL)) {
17632 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17633 HANDLE_EXCEPTION();
17634 }
17635 }
17636 zend_throw_error(NULL, "Method name must be a string");
17637 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17638 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17639 HANDLE_EXCEPTION();
17640 } while (0);
17641 }
17642
17643 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
17644 obj = Z_OBJ_P(object);
17645 } else {
17646 do {
17647 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
17648 obj = Z_OBJ_P(object);
17649 } else {
17650 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
17651 zend_reference *ref = Z_REF_P(object);
17652
17653 object = &ref->val;
17654 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
17655 obj = Z_OBJ_P(object);
17656 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
17657 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
17658 efree_size(ref, sizeof(zend_reference));
17659 } else {
17660 Z_ADDREF_P(object);
17661 }
17662 }
17663 break;
17664 }
17665 }
17666 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
17667 object = ZVAL_UNDEFINED_OP1();
17668 if (UNEXPECTED(EG(exception) != NULL)) {
17669 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17670 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17671 }
17672 HANDLE_EXCEPTION();
17673 }
17674 }
17675 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17676 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17677 }
17678 zend_invalid_method_call(object, function_name);
17679 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17680 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17681 HANDLE_EXCEPTION();
17682 }
17683 } while (0);
17684 }
17685
17686 called_scope = obj->ce;
17687
17688 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
17689 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
17690 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
17691 } else {
17692 zend_object *orig_obj = obj;
17693
17694 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17695 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17696 }
17697
17698 /* First, locate the function. */
17699 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));
17700 if (UNEXPECTED(fbc == NULL)) {
17701 if (EXPECTED(!EG(exception))) {
17702 zend_undefined_method(obj->ce, Z_STR_P(function_name));
17703 }
17704 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17705 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
17706 zend_objects_store_del(orig_obj);
17707 }
17708 HANDLE_EXCEPTION();
17709 }
17710 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
17711 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
17712 EXPECTED(obj == orig_obj)) {
17713 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
17714 }
17715 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
17716 GC_ADDREF(obj); /* For $this pointer */
17717 if (GC_DELREF(orig_obj) == 0) {
17718 zend_objects_store_del(orig_obj);
17719 }
17720 }
17721 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
17722 init_func_run_time_cache(&fbc->op_array);
17723 }
17724 }
17725
17726 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17727 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17728 }
17729
17730 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
17731 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
17732 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
17733 zend_objects_store_del(obj);
17734 if (UNEXPECTED(EG(exception))) {
17735 HANDLE_EXCEPTION();
17736 }
17737 }
17738 /* call static method */
17739 obj = (zend_object*)called_scope;
17740 call_info = ZEND_CALL_NESTED_FUNCTION;
17741 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
17742 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
17743 GC_ADDREF(obj); /* For $this pointer */
17744 }
17745 /* CV may be changed indirectly (e.g. when it's a reference) */
17746 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
17747 }
17748
17749 call = zend_vm_stack_push_call_frame(call_info,
17750 fbc, opline->extended_value, obj);
17751 call->prev_execute_data = EX(call);
17752 EX(call) = call;
17753
17754 ZEND_VM_NEXT_OPCODE();
17755 }
17756
ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17757 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17758 {
17759 USE_OPLINE
17760 zval *op1, *op2;
17761 double d1, d2;
17762
17763 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17764 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17765 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17766 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17767 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17768 case_true:
17769 ZEND_VM_SMART_BRANCH_TRUE();
17770 } else {
17771 case_false:
17772 ZEND_VM_SMART_BRANCH_FALSE();
17773 }
17774 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17775 d1 = (double)Z_LVAL_P(op1);
17776 d2 = Z_DVAL_P(op2);
17777 goto case_double;
17778 }
17779 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17780 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17781 d1 = Z_DVAL_P(op1);
17782 d2 = Z_DVAL_P(op2);
17783 case_double:
17784 if (d1 == d2) {
17785 goto case_true;
17786 } else {
17787 goto case_false;
17788 }
17789 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17790 d1 = Z_DVAL_P(op1);
17791 d2 = (double)Z_LVAL_P(op2);
17792 goto case_double;
17793 }
17794 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17795 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17796 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17797 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17798 if (result) {
17799 goto case_true;
17800 } else {
17801 goto case_false;
17802 }
17803 }
17804 }
17805 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17806 }
17807
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17808 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17809 {
17810 USE_OPLINE
17811 zval *container;
17812 bool result;
17813 zend_ulong hval;
17814 zval *offset;
17815
17816 SAVE_OPLINE();
17817 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17818 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17819
17820 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17821 HashTable *ht;
17822 zval *value;
17823 zend_string *str;
17824
17825 isset_dim_obj_array:
17826 ht = Z_ARRVAL_P(container);
17827 isset_again:
17828 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
17829 str = Z_STR_P(offset);
17830 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17831 if (ZEND_HANDLE_NUMERIC(str, hval)) {
17832 goto num_index_prop;
17833 }
17834 }
17835 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
17836 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
17837 hval = Z_LVAL_P(offset);
17838 num_index_prop:
17839 value = zend_hash_index_find(ht, hval);
17840 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
17841 offset = Z_REFVAL_P(offset);
17842 goto isset_again;
17843 } else {
17844 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
17845 if (UNEXPECTED(EG(exception))) {
17846 result = 0;
17847 goto isset_dim_obj_exit;
17848 }
17849 }
17850
17851 if (!(opline->extended_value & ZEND_ISEMPTY)) {
17852 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
17853 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
17854 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
17855
17856 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
17857 /* avoid exception check */
17858 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17859 ZEND_VM_SMART_BRANCH(result, 0);
17860 }
17861 } else {
17862 result = (value == NULL || !i_zend_is_true(value));
17863 }
17864 goto isset_dim_obj_exit;
17865 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
17866 container = Z_REFVAL_P(container);
17867 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17868 goto isset_dim_obj_array;
17869 }
17870 }
17871
17872 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
17873 offset++;
17874 }
17875 if (!(opline->extended_value & ZEND_ISEMPTY)) {
17876 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
17877 } else {
17878 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
17879 }
17880
17881 isset_dim_obj_exit:
17882 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17883 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17884 ZEND_VM_SMART_BRANCH(result, 1);
17885 }
17886
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17887 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17888 {
17889 USE_OPLINE
17890 zval *container;
17891 int result;
17892 zval *offset;
17893 zend_string *name, *tmp_name;
17894
17895 SAVE_OPLINE();
17896 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17897 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17898
17899 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17900 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17901 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17902 container = Z_REFVAL_P(container);
17903 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
17904 result = (opline->extended_value & ZEND_ISEMPTY);
17905 goto isset_object_finish;
17906 }
17907 } else {
17908 result = (opline->extended_value & ZEND_ISEMPTY);
17909 goto isset_object_finish;
17910 }
17911 }
17912
17913 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17914 name = Z_STR_P(offset);
17915 } else {
17916 name = zval_try_get_tmp_string(offset, &tmp_name);
17917 if (UNEXPECTED(!name)) {
17918 result = 0;
17919 goto isset_object_finish;
17920 }
17921 }
17922
17923 result =
17924 (opline->extended_value & ZEND_ISEMPTY) ^
17925 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));
17926
17927 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17928 zend_tmp_string_release(tmp_name);
17929 }
17930
17931 isset_object_finish:
17932 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17933 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17934 ZEND_VM_SMART_BRANCH(result, 1);
17935 }
17936
ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17937 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17938 {
17939 USE_OPLINE
17940
17941 zval *key, *subject;
17942 HashTable *ht;
17943 bool result;
17944
17945 SAVE_OPLINE();
17946
17947 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17948 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17949
17950 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
17951 array_key_exists_array:
17952 ht = Z_ARRVAL_P(subject);
17953 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
17954 } else {
17955 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
17956 subject = Z_REFVAL_P(subject);
17957 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
17958 goto array_key_exists_array;
17959 }
17960 }
17961 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
17962 result = 0;
17963 }
17964
17965 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17966 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17967 ZEND_VM_SMART_BRANCH(result, 1);
17968 }
17969
17970 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17971 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17972 {
17973 USE_OPLINE
17974 zval *expr;
17975 bool result;
17976
17977 SAVE_OPLINE();
17978 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17979
17980 try_instanceof:
17981 if (Z_TYPE_P(expr) == IS_OBJECT) {
17982 zend_class_entry *ce;
17983
17984 if (IS_VAR == IS_CONST) {
17985 ce = CACHED_PTR(opline->extended_value);
17986 if (UNEXPECTED(ce == NULL)) {
17987 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);
17988 if (EXPECTED(ce)) {
17989 CACHE_PTR(opline->extended_value, ce);
17990 }
17991 }
17992 } else if (IS_VAR == IS_UNUSED) {
17993 ce = zend_fetch_class(NULL, opline->op2.num);
17994 if (UNEXPECTED(ce == NULL)) {
17995 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17996 ZVAL_UNDEF(EX_VAR(opline->result.var));
17997 HANDLE_EXCEPTION();
17998 }
17999 } else {
18000 ce = Z_CE_P(EX_VAR(opline->op2.var));
18001 }
18002 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18003 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18004 expr = Z_REFVAL_P(expr);
18005 goto try_instanceof;
18006 } else {
18007 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18008 ZVAL_UNDEFINED_OP1();
18009 }
18010 result = 0;
18011 }
18012 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18013 ZEND_VM_SMART_BRANCH(result, 1);
18014 }
18015
zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)18016 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)
18017 {
18018 USE_OPLINE
18019 zval *varname;
18020 zval *retval;
18021 zend_string *name, *tmp_name;
18022 HashTable *target_symbol_table;
18023
18024 SAVE_OPLINE();
18025 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18026
18027 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18028 name = Z_STR_P(varname);
18029 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18030 name = Z_STR_P(varname);
18031 tmp_name = NULL;
18032 } else {
18033 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18034 ZVAL_UNDEFINED_OP1();
18035 }
18036 name = zval_try_get_tmp_string(varname, &tmp_name);
18037 if (UNEXPECTED(!name)) {
18038 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18039 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18040 }
18041 ZVAL_UNDEF(EX_VAR(opline->result.var));
18042 HANDLE_EXCEPTION();
18043 }
18044 }
18045
18046 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18047 retval = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18048 if (retval == NULL) {
18049 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18050 fetch_this:
18051 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
18052 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18053 zend_tmp_string_release(tmp_name);
18054 }
18055 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18056 }
18057 if (type == BP_VAR_W) {
18058 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
18059 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18060 retval = &EG(uninitialized_zval);
18061 } else {
18062 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18063 /* Keep name alive in case an error handler tries to free it. */
18064 zend_string_addref(name);
18065 }
18066 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18067 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18068 if (type == BP_VAR_RW && !EG(exception)) {
18069 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
18070 } else {
18071 retval = &EG(uninitialized_zval);
18072 }
18073 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18074 zend_string_release(name);
18075 }
18076 }
18077 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
18078 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
18079 retval = Z_INDIRECT_P(retval);
18080 if (Z_TYPE_P(retval) == IS_UNDEF) {
18081 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18082 goto fetch_this;
18083 }
18084 if (type == BP_VAR_W) {
18085 ZVAL_NULL(retval);
18086 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18087 retval = &EG(uninitialized_zval);
18088 } else {
18089 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18090 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18091 if (type == BP_VAR_RW && !EG(exception)) {
18092 ZVAL_NULL(retval);
18093 } else {
18094 retval = &EG(uninitialized_zval);
18095 }
18096 }
18097 }
18098 }
18099
18100 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18101 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18102 }
18103
18104 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18105 zend_tmp_string_release(tmp_name);
18106 }
18107
18108 ZEND_ASSERT(retval != NULL);
18109 if (type == BP_VAR_R || type == BP_VAR_IS) {
18110 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18111 } else {
18112 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
18113 }
18114 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18115 }
18116
ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18117 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18118 {
18119 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18120 }
18121
ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18122 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18123 {
18124 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18125 }
18126
ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18127 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18128 {
18129 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18130 }
18131
ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18132 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18133 {
18134 int fetch_type =
18135 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
18136 BP_VAR_W : BP_VAR_R;
18137 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18138 }
18139
ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18140 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18141 {
18142 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18143 }
18144
ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18145 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18146 {
18147 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18148 }
18149
18150 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18151 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18152 {
18153 USE_OPLINE
18154 zval *value, *arg;
18155
18156 if (IS_UNUSED == IS_CONST) {
18157 SAVE_OPLINE();
18158 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
18159 uint32_t arg_num;
18160 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
18161 if (UNEXPECTED(!arg)) {
18162 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18163 HANDLE_EXCEPTION();
18164 }
18165 } else {
18166 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
18167 }
18168
18169 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18170 ZVAL_COPY_VALUE(arg, value);
18171 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18172 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
18173 Z_ADDREF_P(arg);
18174 }
18175 }
18176 ZEND_VM_NEXT_OPCODE();
18177 }
18178
ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18179 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18180 {
18181 USE_OPLINE
18182 zval *varname;
18183 zend_string *name, *tmp_name;
18184 HashTable *target_symbol_table;
18185
18186 SAVE_OPLINE();
18187
18188 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18189
18190 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18191 name = Z_STR_P(varname);
18192 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18193 name = Z_STR_P(varname);
18194 tmp_name = NULL;
18195 } else {
18196 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18197 varname = ZVAL_UNDEFINED_OP1();
18198 }
18199 name = zval_try_get_tmp_string(varname, &tmp_name);
18200 if (UNEXPECTED(!name)) {
18201 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18202 HANDLE_EXCEPTION();
18203 }
18204 }
18205
18206 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18207 zend_hash_del_ind(target_symbol_table, name);
18208
18209 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18210 zend_tmp_string_release(tmp_name);
18211 }
18212 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18213 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18214 }
18215
18216 /* 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)18217 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18218 {
18219 USE_OPLINE
18220 zval *value;
18221 /* Should be bool result? as below got: result = (opline->extended_value & ZEND_ISEMPTY) */
18222 int result;
18223 zval *varname;
18224 zend_string *name, *tmp_name;
18225 HashTable *target_symbol_table;
18226
18227 SAVE_OPLINE();
18228 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18229 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18230 name = Z_STR_P(varname);
18231 } else {
18232 name = zval_get_tmp_string(varname, &tmp_name);
18233 }
18234
18235 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18236 value = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18237
18238 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18239 zend_tmp_string_release(tmp_name);
18240 }
18241 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18242
18243 if (!value) {
18244 result = (opline->extended_value & ZEND_ISEMPTY);
18245 } else {
18246 if (Z_TYPE_P(value) == IS_INDIRECT) {
18247 value = Z_INDIRECT_P(value);
18248 }
18249 if (!(opline->extended_value & ZEND_ISEMPTY)) {
18250 if (Z_ISREF_P(value)) {
18251 value = Z_REFVAL_P(value);
18252 }
18253 result = Z_TYPE_P(value) > IS_NULL;
18254 } else {
18255 result = !i_zend_is_true(value);
18256 }
18257 }
18258
18259 ZEND_VM_SMART_BRANCH(result, 1);
18260 }
18261
18262 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18263 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18264 {
18265 USE_OPLINE
18266 zval *expr;
18267 bool result;
18268
18269 SAVE_OPLINE();
18270 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18271
18272 try_instanceof:
18273 if (Z_TYPE_P(expr) == IS_OBJECT) {
18274 zend_class_entry *ce;
18275
18276 if (IS_UNUSED == IS_CONST) {
18277 ce = CACHED_PTR(opline->extended_value);
18278 if (UNEXPECTED(ce == NULL)) {
18279 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);
18280 if (EXPECTED(ce)) {
18281 CACHE_PTR(opline->extended_value, ce);
18282 }
18283 }
18284 } else if (IS_UNUSED == IS_UNUSED) {
18285 ce = zend_fetch_class(NULL, opline->op2.num);
18286 if (UNEXPECTED(ce == NULL)) {
18287 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18288 ZVAL_UNDEF(EX_VAR(opline->result.var));
18289 HANDLE_EXCEPTION();
18290 }
18291 } else {
18292 ce = Z_CE_P(EX_VAR(opline->op2.var));
18293 }
18294 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18295 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18296 expr = Z_REFVAL_P(expr);
18297 goto try_instanceof;
18298 } else {
18299 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18300 ZVAL_UNDEFINED_OP1();
18301 }
18302 result = 0;
18303 }
18304 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18305 ZEND_VM_SMART_BRANCH(result, 1);
18306 }
18307
ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18308 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18309 {
18310 USE_OPLINE
18311 zval *op1;
18312 zend_long count;
18313
18314 SAVE_OPLINE();
18315 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18316
18317 while (1) {
18318 if (Z_TYPE_P(op1) == IS_ARRAY) {
18319 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
18320 break;
18321 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
18322 zend_object *zobj = Z_OBJ_P(op1);
18323
18324 /* first, we check if the handler is defined */
18325 if (zobj->handlers->count_elements) {
18326 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
18327 break;
18328 }
18329 if (UNEXPECTED(EG(exception))) {
18330 count = 0;
18331 break;
18332 }
18333 }
18334
18335 /* if not and the object implements Countable we call its count() method */
18336 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
18337 zval retval;
18338
18339 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
18340 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
18341 count = zval_get_long(&retval);
18342 zval_ptr_dtor(&retval);
18343 break;
18344 }
18345
18346 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
18347 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
18348 op1 = Z_REFVAL_P(op1);
18349 continue;
18350 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18351 ZVAL_UNDEFINED_OP1();
18352 }
18353 count = 0;
18354 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));
18355 break;
18356 }
18357
18358 ZVAL_LONG(EX_VAR(opline->result.var), count);
18359 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18360 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18361 }
18362
ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18363 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18364 {
18365 USE_OPLINE
18366 zend_array *ht = Z_ARRVAL_P(_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC));
18367 ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
18368 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
18369 SAVE_OPLINE();
18370 zend_array_destroy(ht);
18371 if (EG(exception)) {
18372 HANDLE_EXCEPTION();
18373 }
18374 }
18375 ZEND_VM_NEXT_OPCODE();
18376 }
18377
ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18378 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18379 {
18380 USE_OPLINE
18381
18382 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
18383 SAVE_OPLINE();
18384 if (UNEXPECTED(!EX(func)->common.scope)) {
18385 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
18386 ZVAL_UNDEF(EX_VAR(opline->result.var));
18387 HANDLE_EXCEPTION();
18388 } else {
18389 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
18390 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
18391 if (UNEXPECTED(EG(exception))) {
18392 HANDLE_EXCEPTION();
18393 }
18394 ZEND_VM_NEXT_OPCODE();
18395 }
18396 } else {
18397 zval *op1;
18398
18399 SAVE_OPLINE();
18400 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18401 while (1) {
18402 if (Z_TYPE_P(op1) == IS_OBJECT) {
18403 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
18404 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
18405 op1 = Z_REFVAL_P(op1);
18406 continue;
18407 } else {
18408 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18409 ZVAL_UNDEFINED_OP1();
18410 }
18411 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
18412 ZVAL_UNDEF(EX_VAR(opline->result.var));
18413 }
18414 break;
18415 }
18416 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18417 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18418 }
18419 }
18420
ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18421 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18422 {
18423 USE_OPLINE
18424 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18425 zval *result = EX_VAR(opline->result.var);
18426 ZVAL_COPY(result, value);
18427 ZEND_VM_NEXT_OPCODE();
18428 }
18429
ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18430 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18431 {
18432 USE_OPLINE
18433 zval *op1, *op2;
18434
18435 SAVE_OPLINE();
18436 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18437 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18438 div_function(EX_VAR(opline->result.var), op1, op2);
18439 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18440
18441 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18442 }
18443
ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18444 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18445 {
18446 USE_OPLINE
18447 zval *op1, *op2;
18448
18449 SAVE_OPLINE();
18450 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18451 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18452 pow_function(EX_VAR(opline->result.var), op1, op2);
18453 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18454
18455 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18456 }
18457
ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18458 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18459 {
18460 USE_OPLINE
18461 zval *op1, *op2;
18462
18463 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18464 op2 = EX_VAR(opline->op2.var);
18465
18466 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
18467 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
18468 zend_string *op1_str = Z_STR_P(op1);
18469 zend_string *op2_str = Z_STR_P(op2);
18470 zend_string *str;
18471 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
18472
18473 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18474 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
18475 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
18476 } else {
18477 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18478 }
18479 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18480 zend_string_release_ex(op1_str, 0);
18481 }
18482 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18483 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
18484 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
18485 } else {
18486 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18487 }
18488 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18489 zend_string_release_ex(op2_str, 0);
18490 }
18491 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
18492 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
18493 size_t len = ZSTR_LEN(op1_str);
18494
18495 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
18496 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
18497 }
18498 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
18499 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18500 GC_ADD_FLAGS(str, flags);
18501 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18502 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18503 zend_string_release_ex(op2_str, 0);
18504 }
18505 } else {
18506 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18507 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18508 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18509 GC_ADD_FLAGS(str, flags);
18510 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18511 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18512 zend_string_release_ex(op1_str, 0);
18513 }
18514 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18515 zend_string_release_ex(op2_str, 0);
18516 }
18517 }
18518 ZEND_VM_NEXT_OPCODE();
18519 } else {
18520 SAVE_OPLINE();
18521
18522 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18523 op1 = ZVAL_UNDEFINED_OP1();
18524 }
18525 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
18526 op2 = ZVAL_UNDEFINED_OP2();
18527 }
18528 concat_function(EX_VAR(opline->result.var), op1, op2);
18529 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18530
18531 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18532 }
18533 }
18534
ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18535 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18536 {
18537 USE_OPLINE
18538 zval *op1, *op2;
18539
18540 SAVE_OPLINE();
18541 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18542 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18543 compare_function(EX_VAR(opline->result.var), op1, op2);
18544 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18545
18546 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18547 }
18548
ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18549 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18550 {
18551 USE_OPLINE
18552 zval *container, *dim, *value;
18553
18554 SAVE_OPLINE();
18555 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18556 dim = EX_VAR(opline->op2.var);
18557 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18558 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18559 fetch_dim_r_array:
18560 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
18561 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
18562 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
18563 container = Z_REFVAL_P(container);
18564 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18565 goto fetch_dim_r_array;
18566 } else {
18567 goto fetch_dim_r_slow;
18568 }
18569 } else {
18570 fetch_dim_r_slow:
18571 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
18572 dim++;
18573 }
18574 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
18575 }
18576 } else {
18577 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
18578 }
18579
18580 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18581 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18582 }
18583
ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18584 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18585 {
18586 USE_OPLINE
18587 zval *container;
18588
18589 SAVE_OPLINE();
18590 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18591 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
18592
18593 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18594 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18595 }
18596
ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18597 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18598 {
18599 USE_OPLINE
18600 zval *container;
18601 void **cache_slot = NULL;
18602
18603 SAVE_OPLINE();
18604 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18605
18606 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
18607 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
18608 do {
18609 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
18610 container = Z_REFVAL_P(container);
18611 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
18612 break;
18613 }
18614 }
18615 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
18616 ZVAL_UNDEFINED_OP1();
18617 }
18618 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
18619 ZVAL_NULL(EX_VAR(opline->result.var));
18620 goto fetch_obj_r_finish;
18621 } while (0);
18622 }
18623
18624 /* here we are sure we are dealing with an object */
18625 do {
18626 zend_object *zobj = Z_OBJ_P(container);
18627 zend_string *name, *tmp_name;
18628 zval *retval;
18629
18630 if (IS_CV == IS_CONST) {
18631 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
18632
18633 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
18634 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
18635
18636 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
18637 retval = OBJ_PROP(zobj, prop_offset);
18638 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
18639 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18640 goto fetch_obj_r_copy;
18641 } else {
18642 fetch_obj_r_fast_copy:
18643 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18644 ZEND_VM_NEXT_OPCODE();
18645 }
18646 }
18647 } else if (EXPECTED(zobj->properties != NULL)) {
18648 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
18649 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
18650 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
18651
18652 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
18653 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
18654
18655 if (EXPECTED(p->key == name) ||
18656 (EXPECTED(p->h == ZSTR_H(name)) &&
18657 EXPECTED(p->key != NULL) &&
18658 EXPECTED(zend_string_equal_content(p->key, name)))) {
18659 retval = &p->val;
18660 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18661 goto fetch_obj_r_copy;
18662 } else {
18663 goto fetch_obj_r_fast_copy;
18664 }
18665 }
18666 }
18667 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
18668 }
18669 retval = zend_hash_find_known_hash(zobj->properties, name);
18670 if (EXPECTED(retval)) {
18671 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
18672 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
18673 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18674 goto fetch_obj_r_copy;
18675 } else {
18676 goto fetch_obj_r_fast_copy;
18677 }
18678 }
18679 }
18680 }
18681 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
18682 } else {
18683 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
18684 if (UNEXPECTED(!name)) {
18685 ZVAL_UNDEF(EX_VAR(opline->result.var));
18686 break;
18687 }
18688 }
18689
18690 #if ZEND_DEBUG
18691 /* For non-standard object handlers, verify a declared property type in debug builds.
18692 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
18693 zend_property_info *prop_info = NULL;
18694 if (zobj->handlers->read_property != zend_std_read_property) {
18695 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
18696 }
18697 #endif
18698 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
18699 #if ZEND_DEBUG
18700 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
18701 && ZEND_TYPE_IS_SET(prop_info->type)) {
18702 ZVAL_OPT_DEREF(retval);
18703 zend_verify_property_type(prop_info, retval, /* strict */ true);
18704 }
18705 #endif
18706
18707 if (IS_CV != IS_CONST) {
18708 zend_tmp_string_release(tmp_name);
18709 }
18710
18711 if (retval != EX_VAR(opline->result.var)) {
18712 fetch_obj_r_copy:
18713 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18714 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
18715 zend_unwrap_reference(retval);
18716 }
18717 } while (0);
18718
18719 fetch_obj_r_finish:
18720
18721 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18722 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18723 }
18724
ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18725 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18726 {
18727 USE_OPLINE
18728 zval *container;
18729 void **cache_slot = NULL;
18730
18731 SAVE_OPLINE();
18732 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18733
18734 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
18735 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
18736 do {
18737 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
18738 container = Z_REFVAL_P(container);
18739 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
18740 break;
18741 }
18742 }
18743 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
18744 ZVAL_UNDEFINED_OP2();
18745 }
18746 ZVAL_NULL(EX_VAR(opline->result.var));
18747 goto fetch_obj_is_finish;
18748 } while (0);
18749 }
18750
18751 /* here we are sure we are dealing with an object */
18752 do {
18753 zend_object *zobj = Z_OBJ_P(container);
18754 zend_string *name, *tmp_name;
18755 zval *retval;
18756
18757 if (IS_CV == IS_CONST) {
18758 cache_slot = CACHE_ADDR(opline->extended_value);
18759
18760 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
18761 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
18762
18763 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
18764 retval = OBJ_PROP(zobj, prop_offset);
18765 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
18766 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18767 goto fetch_obj_is_copy;
18768 } else {
18769 fetch_obj_is_fast_copy:
18770 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18771 ZEND_VM_NEXT_OPCODE();
18772 }
18773 }
18774 } else if (EXPECTED(zobj->properties != NULL)) {
18775 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
18776 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
18777 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
18778
18779 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
18780 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
18781
18782 if (EXPECTED(p->key == name) ||
18783 (EXPECTED(p->h == ZSTR_H(name)) &&
18784 EXPECTED(p->key != NULL) &&
18785 EXPECTED(zend_string_equal_content(p->key, name)))) {
18786 retval = &p->val;
18787 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18788 goto fetch_obj_is_copy;
18789 } else {
18790 goto fetch_obj_is_fast_copy;
18791 }
18792 }
18793 }
18794 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
18795 }
18796 retval = zend_hash_find_known_hash(zobj->properties, name);
18797 if (EXPECTED(retval)) {
18798 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
18799 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
18800 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18801 goto fetch_obj_is_copy;
18802 } else {
18803 goto fetch_obj_is_fast_copy;
18804 }
18805 }
18806 }
18807 }
18808 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
18809 } else {
18810 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
18811 if (UNEXPECTED(!name)) {
18812 ZVAL_UNDEF(EX_VAR(opline->result.var));
18813 break;
18814 }
18815 }
18816
18817 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
18818
18819 if (IS_CV != IS_CONST) {
18820 zend_tmp_string_release(tmp_name);
18821 }
18822
18823 if (retval != EX_VAR(opline->result.var)) {
18824 fetch_obj_is_copy:
18825 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18826 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
18827 zend_unwrap_reference(retval);
18828 }
18829 } while (0);
18830
18831 fetch_obj_is_finish:
18832
18833 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18834 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18835 }
18836
ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18837 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18838 {
18839 USE_OPLINE
18840 zval *op1, *op2;
18841 zend_string *op1_str, *op2_str, *str;
18842
18843
18844 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18845 op2 = EX_VAR(opline->op2.var);
18846 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
18847 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
18848 zend_string *op1_str = Z_STR_P(op1);
18849 zend_string *op2_str = Z_STR_P(op2);
18850 zend_string *str;
18851 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
18852
18853 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18854 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
18855 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
18856 } else {
18857 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18858 }
18859 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18860 zend_string_release_ex(op1_str, 0);
18861 }
18862 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18863 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
18864 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
18865 } else {
18866 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18867 }
18868 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18869 zend_string_release_ex(op2_str, 0);
18870 }
18871 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
18872 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
18873 size_t len = ZSTR_LEN(op1_str);
18874
18875 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
18876 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18877 GC_ADD_FLAGS(str, flags);
18878 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18879 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18880 zend_string_release_ex(op2_str, 0);
18881 }
18882 } else {
18883 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18884 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18885 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18886 GC_ADD_FLAGS(str, flags);
18887 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18888 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18889 zend_string_release_ex(op1_str, 0);
18890 }
18891 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18892 zend_string_release_ex(op2_str, 0);
18893 }
18894 }
18895 ZEND_VM_NEXT_OPCODE();
18896 }
18897
18898 SAVE_OPLINE();
18899 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18900 op1_str = Z_STR_P(op1);
18901 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
18902 op1_str = zend_string_copy(Z_STR_P(op1));
18903 } else {
18904 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18905 ZVAL_UNDEFINED_OP1();
18906 }
18907 op1_str = zval_get_string_func(op1);
18908 }
18909 if (IS_CV == IS_CONST) {
18910 op2_str = Z_STR_P(op2);
18911 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
18912 op2_str = zend_string_copy(Z_STR_P(op2));
18913 } else {
18914 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
18915 ZVAL_UNDEFINED_OP2();
18916 }
18917 op2_str = zval_get_string_func(op2);
18918 }
18919 do {
18920 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18921 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18922 if (IS_CV == IS_CONST) {
18923 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
18924 GC_ADDREF(op2_str);
18925 }
18926 }
18927 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18928 zend_string_release_ex(op1_str, 0);
18929 break;
18930 }
18931 }
18932 if (IS_CV != IS_CONST) {
18933 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18934 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18935 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
18936 GC_ADDREF(op1_str);
18937 }
18938 }
18939 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18940 zend_string_release_ex(op2_str, 0);
18941 break;
18942 }
18943 }
18944 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18945 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18946 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18947
18948 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
18949 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18950 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18951 zend_string_release_ex(op1_str, 0);
18952 }
18953 if (IS_CV != IS_CONST) {
18954 zend_string_release_ex(op2_str, 0);
18955 }
18956 } while (0);
18957 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18958
18959 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18960 }
18961
ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18962 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18963 {
18964 USE_OPLINE
18965 zval *function_name;
18966 zval *object;
18967 zend_function *fbc;
18968 zend_class_entry *called_scope;
18969 zend_object *obj;
18970 zend_execute_data *call;
18971 uint32_t call_info;
18972
18973 SAVE_OPLINE();
18974
18975 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18976
18977 if (IS_CV != IS_CONST) {
18978 function_name = EX_VAR(opline->op2.var);
18979 }
18980
18981 if (IS_CV != IS_CONST &&
18982 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
18983 do {
18984 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
18985 function_name = Z_REFVAL_P(function_name);
18986 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
18987 break;
18988 }
18989 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
18990 ZVAL_UNDEFINED_OP2();
18991 if (UNEXPECTED(EG(exception) != NULL)) {
18992 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18993 HANDLE_EXCEPTION();
18994 }
18995 }
18996 zend_throw_error(NULL, "Method name must be a string");
18997
18998 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18999 HANDLE_EXCEPTION();
19000 } while (0);
19001 }
19002
19003 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
19004 obj = Z_OBJ_P(object);
19005 } else {
19006 do {
19007 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
19008 obj = Z_OBJ_P(object);
19009 } else {
19010 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
19011 zend_reference *ref = Z_REF_P(object);
19012
19013 object = &ref->val;
19014 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
19015 obj = Z_OBJ_P(object);
19016 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
19017 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19018 efree_size(ref, sizeof(zend_reference));
19019 } else {
19020 Z_ADDREF_P(object);
19021 }
19022 }
19023 break;
19024 }
19025 }
19026 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
19027 object = ZVAL_UNDEFINED_OP1();
19028 if (UNEXPECTED(EG(exception) != NULL)) {
19029 if (IS_CV != IS_CONST) {
19030
19031 }
19032 HANDLE_EXCEPTION();
19033 }
19034 }
19035 if (IS_CV == IS_CONST) {
19036 function_name = EX_VAR(opline->op2.var);
19037 }
19038 zend_invalid_method_call(object, function_name);
19039
19040 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19041 HANDLE_EXCEPTION();
19042 }
19043 } while (0);
19044 }
19045
19046 called_scope = obj->ce;
19047
19048 if (IS_CV == IS_CONST &&
19049 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
19050 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
19051 } else {
19052 zend_object *orig_obj = obj;
19053
19054 if (IS_CV == IS_CONST) {
19055 function_name = EX_VAR(opline->op2.var);
19056 }
19057
19058 /* First, locate the function. */
19059 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
19060 if (UNEXPECTED(fbc == NULL)) {
19061 if (EXPECTED(!EG(exception))) {
19062 zend_undefined_method(obj->ce, Z_STR_P(function_name));
19063 }
19064
19065 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
19066 zend_objects_store_del(orig_obj);
19067 }
19068 HANDLE_EXCEPTION();
19069 }
19070 if (IS_CV == IS_CONST &&
19071 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
19072 EXPECTED(obj == orig_obj)) {
19073 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
19074 }
19075 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
19076 GC_ADDREF(obj); /* For $this pointer */
19077 if (GC_DELREF(orig_obj) == 0) {
19078 zend_objects_store_del(orig_obj);
19079 }
19080 }
19081 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
19082 init_func_run_time_cache(&fbc->op_array);
19083 }
19084 }
19085
19086 if (IS_CV != IS_CONST) {
19087
19088 }
19089
19090 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
19091 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
19092 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
19093 zend_objects_store_del(obj);
19094 if (UNEXPECTED(EG(exception))) {
19095 HANDLE_EXCEPTION();
19096 }
19097 }
19098 /* call static method */
19099 obj = (zend_object*)called_scope;
19100 call_info = ZEND_CALL_NESTED_FUNCTION;
19101 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
19102 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
19103 GC_ADDREF(obj); /* For $this pointer */
19104 }
19105 /* CV may be changed indirectly (e.g. when it's a reference) */
19106 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
19107 }
19108
19109 call = zend_vm_stack_push_call_frame(call_info,
19110 fbc, opline->extended_value, obj);
19111 call->prev_execute_data = EX(call);
19112 EX(call) = call;
19113
19114 ZEND_VM_NEXT_OPCODE();
19115 }
19116
ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19117 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19118 {
19119 USE_OPLINE
19120 zval *op1, *op2;
19121 double d1, d2;
19122
19123 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19124 op2 = EX_VAR(opline->op2.var);
19125 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
19126 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19127 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
19128 case_true:
19129 ZEND_VM_SMART_BRANCH_TRUE();
19130 } else {
19131 case_false:
19132 ZEND_VM_SMART_BRANCH_FALSE();
19133 }
19134 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19135 d1 = (double)Z_LVAL_P(op1);
19136 d2 = Z_DVAL_P(op2);
19137 goto case_double;
19138 }
19139 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
19140 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19141 d1 = Z_DVAL_P(op1);
19142 d2 = Z_DVAL_P(op2);
19143 case_double:
19144 if (d1 == d2) {
19145 goto case_true;
19146 } else {
19147 goto case_false;
19148 }
19149 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19150 d1 = Z_DVAL_P(op1);
19151 d2 = (double)Z_LVAL_P(op2);
19152 goto case_double;
19153 }
19154 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
19155 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
19156 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
19157
19158 if (result) {
19159 goto case_true;
19160 } else {
19161 goto case_false;
19162 }
19163 }
19164 }
19165 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
19166 }
19167
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19168 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19169 {
19170 USE_OPLINE
19171 zval *container;
19172 bool result;
19173 zend_ulong hval;
19174 zval *offset;
19175
19176 SAVE_OPLINE();
19177 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19178 offset = EX_VAR(opline->op2.var);
19179
19180 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19181 HashTable *ht;
19182 zval *value;
19183 zend_string *str;
19184
19185 isset_dim_obj_array:
19186 ht = Z_ARRVAL_P(container);
19187 isset_again:
19188 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
19189 str = Z_STR_P(offset);
19190 if (IS_CV != IS_CONST) {
19191 if (ZEND_HANDLE_NUMERIC(str, hval)) {
19192 goto num_index_prop;
19193 }
19194 }
19195 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
19196 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
19197 hval = Z_LVAL_P(offset);
19198 num_index_prop:
19199 value = zend_hash_index_find(ht, hval);
19200 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
19201 offset = Z_REFVAL_P(offset);
19202 goto isset_again;
19203 } else {
19204 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
19205 if (UNEXPECTED(EG(exception))) {
19206 result = 0;
19207 goto isset_dim_obj_exit;
19208 }
19209 }
19210
19211 if (!(opline->extended_value & ZEND_ISEMPTY)) {
19212 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
19213 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
19214 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
19215
19216 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
19217 /* avoid exception check */
19218
19219 ZEND_VM_SMART_BRANCH(result, 0);
19220 }
19221 } else {
19222 result = (value == NULL || !i_zend_is_true(value));
19223 }
19224 goto isset_dim_obj_exit;
19225 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
19226 container = Z_REFVAL_P(container);
19227 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19228 goto isset_dim_obj_array;
19229 }
19230 }
19231
19232 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
19233 offset++;
19234 }
19235 if (!(opline->extended_value & ZEND_ISEMPTY)) {
19236 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
19237 } else {
19238 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
19239 }
19240
19241 isset_dim_obj_exit:
19242
19243 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19244 ZEND_VM_SMART_BRANCH(result, 1);
19245 }
19246
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19247 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19248 {
19249 USE_OPLINE
19250 zval *container;
19251 int result;
19252 zval *offset;
19253 zend_string *name, *tmp_name;
19254
19255 SAVE_OPLINE();
19256 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19257 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19258
19259 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19260 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19261 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19262 container = Z_REFVAL_P(container);
19263 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
19264 result = (opline->extended_value & ZEND_ISEMPTY);
19265 goto isset_object_finish;
19266 }
19267 } else {
19268 result = (opline->extended_value & ZEND_ISEMPTY);
19269 goto isset_object_finish;
19270 }
19271 }
19272
19273 if (IS_CV == IS_CONST) {
19274 name = Z_STR_P(offset);
19275 } else {
19276 name = zval_try_get_tmp_string(offset, &tmp_name);
19277 if (UNEXPECTED(!name)) {
19278 result = 0;
19279 goto isset_object_finish;
19280 }
19281 }
19282
19283 result =
19284 (opline->extended_value & ZEND_ISEMPTY) ^
19285 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));
19286
19287 if (IS_CV != IS_CONST) {
19288 zend_tmp_string_release(tmp_name);
19289 }
19290
19291 isset_object_finish:
19292
19293 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19294 ZEND_VM_SMART_BRANCH(result, 1);
19295 }
19296
ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19297 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19298 {
19299 USE_OPLINE
19300
19301 zval *key, *subject;
19302 HashTable *ht;
19303 bool result;
19304
19305 SAVE_OPLINE();
19306
19307 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19308 subject = EX_VAR(opline->op2.var);
19309
19310 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
19311 array_key_exists_array:
19312 ht = Z_ARRVAL_P(subject);
19313 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
19314 } else {
19315 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
19316 subject = Z_REFVAL_P(subject);
19317 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
19318 goto array_key_exists_array;
19319 }
19320 }
19321 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
19322 result = 0;
19323 }
19324
19325 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19326 ZEND_VM_SMART_BRANCH(result, 1);
19327 }
19328
19329 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19330 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19331 {
19332 USE_OPLINE
19333 zval *retval_ptr;
19334 zval *return_value;
19335
19336 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19337 return_value = EX(return_value);
19338
19339 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
19340 SAVE_OPLINE();
19341 retval_ptr = ZVAL_UNDEFINED_OP1();
19342 if (return_value) {
19343 ZVAL_NULL(return_value);
19344 }
19345 } else if (!return_value) {
19346 if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
19347 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
19348 SAVE_OPLINE();
19349 rc_dtor_func(Z_COUNTED_P(retval_ptr));
19350 }
19351 }
19352 } else {
19353 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
19354 ZVAL_COPY_VALUE(return_value, retval_ptr);
19355 if (IS_TMP_VAR == IS_CONST) {
19356 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
19357 Z_ADDREF_P(return_value);
19358 }
19359 }
19360 } else if (IS_TMP_VAR == IS_CV) {
19361 do {
19362 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19363 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
19364 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
19365 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
19366 ZVAL_COPY_VALUE(return_value, retval_ptr);
19367 if (GC_MAY_LEAK(ref)) {
19368 SAVE_OPLINE();
19369 gc_possible_root(ref);
19370 }
19371 ZVAL_NULL(retval_ptr);
19372 break;
19373 } else {
19374 Z_ADDREF_P(retval_ptr);
19375 }
19376 } else {
19377 retval_ptr = Z_REFVAL_P(retval_ptr);
19378 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19379 Z_ADDREF_P(retval_ptr);
19380 }
19381 }
19382 }
19383 ZVAL_COPY_VALUE(return_value, retval_ptr);
19384 } while (0);
19385 } else /* if (IS_TMP_VAR == IS_VAR) */ {
19386 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
19387 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
19388
19389 retval_ptr = Z_REFVAL_P(retval_ptr);
19390 ZVAL_COPY_VALUE(return_value, retval_ptr);
19391 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19392 efree_size(ref, sizeof(zend_reference));
19393 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19394 Z_ADDREF_P(retval_ptr);
19395 }
19396 } else {
19397 ZVAL_COPY_VALUE(return_value, retval_ptr);
19398 }
19399 }
19400 }
19401
19402
19403
19404 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
19405 }
19406
ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19407 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19408 {
19409 USE_OPLINE
19410 zval *retval_ptr;
19411 zval *return_value;
19412
19413 SAVE_OPLINE();
19414
19415 return_value = EX(return_value);
19416
19417 do {
19418 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) ||
19419 (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
19420 /* Not supposed to happen, but we'll allow it */
19421 zend_error(E_NOTICE, "Only variable references should be returned by reference");
19422
19423 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19424 if (!return_value) {
19425 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19426 } else {
19427 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
19428 ZVAL_COPY_VALUE(return_value, retval_ptr);
19429 break;
19430 }
19431
19432 ZVAL_NEW_REF(return_value, retval_ptr);
19433 if (IS_TMP_VAR == IS_CONST) {
19434 Z_TRY_ADDREF_P(retval_ptr);
19435 }
19436 }
19437 break;
19438 }
19439
19440 retval_ptr = zend_get_bad_ptr();
19441
19442 if (IS_TMP_VAR == IS_VAR) {
19443 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
19444 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
19445 zend_error(E_NOTICE, "Only variable references should be returned by reference");
19446 if (return_value) {
19447 ZVAL_NEW_REF(return_value, retval_ptr);
19448 } else {
19449 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19450 }
19451 break;
19452 }
19453 }
19454
19455 if (return_value) {
19456 if (Z_ISREF_P(retval_ptr)) {
19457 Z_ADDREF_P(retval_ptr);
19458 } else {
19459 ZVAL_MAKE_REF_EX(retval_ptr, 2);
19460 }
19461 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
19462 }
19463
19464 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19465 } while (0);
19466
19467
19468 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
19469 }
19470
ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19471 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19472 {
19473 USE_OPLINE
19474 zval *retval;
19475
19476 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
19477
19478 SAVE_OPLINE();
19479 retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19480
19481 /* Copy return value into generator->retval */
19482 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
19483 ZVAL_COPY_VALUE(&generator->retval, retval);
19484 if (IS_TMP_VAR == IS_CONST) {
19485 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
19486 Z_ADDREF(generator->retval);
19487 }
19488 }
19489 } else if (IS_TMP_VAR == IS_CV) {
19490 ZVAL_COPY_DEREF(&generator->retval, retval);
19491 } else /* if (IS_TMP_VAR == IS_VAR) */ {
19492 if (UNEXPECTED(Z_ISREF_P(retval))) {
19493 zend_refcounted *ref = Z_COUNTED_P(retval);
19494
19495 retval = Z_REFVAL_P(retval);
19496 ZVAL_COPY_VALUE(&generator->retval, retval);
19497 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19498 efree_size(ref, sizeof(zend_reference));
19499 } else if (Z_OPT_REFCOUNTED_P(retval)) {
19500 Z_ADDREF_P(retval);
19501 }
19502 } else {
19503 ZVAL_COPY_VALUE(&generator->retval, retval);
19504 }
19505 }
19506
19507 EG(current_execute_data) = EX(prev_execute_data);
19508
19509 /* Close the generator to free up resources */
19510 zend_generator_close(generator, 1);
19511
19512 /* Pass execution back to handling code */
19513 ZEND_VM_RETURN();
19514 }
19515
ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19516 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19517 {
19518 USE_OPLINE
19519 zval *arg, *param;
19520
19521 SAVE_OPLINE();
19522
19523 arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19524 param = ZEND_CALL_VAR(EX(call), opline->result.var);
19525 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
19526 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
19527 Z_TRY_ADDREF_P(arg);
19528 ZVAL_NEW_REF(param, arg);
19529 } else {
19530 ZVAL_COPY(param, arg);
19531 }
19532
19533 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19534 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19535 }
19536
ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19537 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19538 {
19539 USE_OPLINE
19540 zval *expr;
19541 zval *result = EX_VAR(opline->result.var);
19542 HashTable *ht;
19543
19544 SAVE_OPLINE();
19545 expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19546
19547 switch (opline->extended_value) {
19548 case IS_LONG:
19549 ZVAL_LONG(result, zval_get_long(expr));
19550 break;
19551 case IS_DOUBLE:
19552 ZVAL_DOUBLE(result, zval_get_double(expr));
19553 break;
19554 case IS_STRING:
19555 ZVAL_STR(result, zval_get_string(expr));
19556 break;
19557 default:
19558 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
19559 if (IS_TMP_VAR & (IS_VAR|IS_CV)) {
19560 ZVAL_DEREF(expr);
19561 }
19562 /* If value is already of correct type, return it directly */
19563 if (Z_TYPE_P(expr) == opline->extended_value) {
19564 ZVAL_COPY_VALUE(result, expr);
19565 if (IS_TMP_VAR == IS_CONST) {
19566 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
19567 } else if (IS_TMP_VAR != IS_TMP_VAR) {
19568 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
19569 }
19570
19571 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19572 }
19573
19574 if (opline->extended_value == IS_ARRAY) {
19575 if (IS_TMP_VAR == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
19576 if (Z_TYPE_P(expr) != IS_NULL) {
19577 ZVAL_ARR(result, zend_new_array(1));
19578 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
19579 if (IS_TMP_VAR == IS_CONST) {
19580 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
19581 } else {
19582 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
19583 }
19584 } else {
19585 ZVAL_EMPTY_ARRAY(result);
19586 }
19587 } else if (Z_OBJ_P(expr)->properties == NULL
19588 && Z_OBJ_HT_P(expr)->get_properties_for == NULL
19589 && Z_OBJ_HT_P(expr)->get_properties == zend_std_get_properties) {
19590 /* Optimized version without rebuilding properties HashTable */
19591 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
19592 } else {
19593 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
19594 if (obj_ht) {
19595 /* fast copy */
19596 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
19597 (Z_OBJCE_P(expr)->default_properties_count ||
19598 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
19599 GC_IS_RECURSIVE(obj_ht))));
19600 zend_release_properties(obj_ht);
19601 } else {
19602 ZVAL_EMPTY_ARRAY(result);
19603 }
19604 }
19605 } else {
19606 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
19607 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
19608 if (Z_TYPE_P(expr) == IS_ARRAY) {
19609 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
19610 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
19611 /* TODO: try not to duplicate immutable arrays as well ??? */
19612 ht = zend_array_dup(ht);
19613 }
19614 Z_OBJ_P(result)->properties = ht;
19615 } else if (Z_TYPE_P(expr) != IS_NULL) {
19616 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
19617 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
19618 if (IS_TMP_VAR == IS_CONST) {
19619 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
19620 } else {
19621 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
19622 }
19623 }
19624 }
19625 }
19626
19627 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19628 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19629 }
19630
ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19631 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19632 {
19633 USE_OPLINE
19634 zval *array_ptr, *result;
19635
19636 SAVE_OPLINE();
19637
19638 array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19639 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
19640 result = EX_VAR(opline->result.var);
19641 ZVAL_COPY_VALUE(result, array_ptr);
19642 if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
19643 Z_ADDREF_P(array_ptr);
19644 }
19645 Z_FE_POS_P(result) = 0;
19646
19647 ZEND_VM_NEXT_OPCODE();
19648 } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
19649 zend_object *zobj = Z_OBJ_P(array_ptr);
19650 if (!zobj->ce->get_iterator) {
19651 HashTable *properties = zobj->properties;
19652 if (properties) {
19653 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
19654 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
19655 GC_DELREF(properties);
19656 }
19657 properties = zobj->properties = zend_array_dup(properties);
19658 }
19659 } else {
19660 properties = zobj->handlers->get_properties(zobj);
19661 }
19662
19663 result = EX_VAR(opline->result.var);
19664 ZVAL_COPY_VALUE(result, array_ptr);
19665 if (IS_TMP_VAR != IS_TMP_VAR) {
19666 Z_ADDREF_P(array_ptr);
19667 }
19668
19669 if (zend_hash_num_elements(properties) == 0) {
19670 Z_FE_ITER_P(result) = (uint32_t) -1;
19671
19672 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
19673 }
19674
19675 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
19676
19677 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19678 } else {
19679 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
19680
19681 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19682 if (UNEXPECTED(EG(exception))) {
19683 HANDLE_EXCEPTION();
19684 } else if (is_empty) {
19685 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
19686 } else {
19687 ZEND_VM_NEXT_OPCODE();
19688 }
19689 }
19690 } else {
19691 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
19692 ZVAL_UNDEF(EX_VAR(opline->result.var));
19693 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
19694 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19695 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
19696 }
19697 }
19698
ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19699 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19700 {
19701 USE_OPLINE
19702 zval *array_ptr, *array_ref;
19703
19704 SAVE_OPLINE();
19705
19706 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
19707 array_ref = array_ptr = zend_get_bad_ptr();
19708 if (Z_ISREF_P(array_ref)) {
19709 array_ptr = Z_REFVAL_P(array_ref);
19710 }
19711 } else {
19712 array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19713 }
19714
19715 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
19716 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
19717 if (array_ptr == array_ref) {
19718 ZVAL_NEW_REF(array_ref, array_ref);
19719 array_ptr = Z_REFVAL_P(array_ref);
19720 }
19721 Z_ADDREF_P(array_ref);
19722 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
19723 } else {
19724 array_ref = EX_VAR(opline->result.var);
19725 ZVAL_NEW_REF(array_ref, array_ptr);
19726 array_ptr = Z_REFVAL_P(array_ref);
19727 }
19728 if (IS_TMP_VAR == IS_CONST) {
19729 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
19730 } else {
19731 SEPARATE_ARRAY(array_ptr);
19732 }
19733 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
19734
19735 ZEND_VM_NEXT_OPCODE();
19736 } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
19737 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
19738 HashTable *properties;
19739 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
19740 if (array_ptr == array_ref) {
19741 ZVAL_NEW_REF(array_ref, array_ref);
19742 array_ptr = Z_REFVAL_P(array_ref);
19743 }
19744 Z_ADDREF_P(array_ref);
19745 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
19746 } else {
19747 array_ptr = EX_VAR(opline->result.var);
19748 ZVAL_COPY_VALUE(array_ptr, array_ref);
19749 }
19750 if (Z_OBJ_P(array_ptr)->properties
19751 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
19752 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
19753 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
19754 }
19755 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
19756 }
19757
19758 properties = Z_OBJPROP_P(array_ptr);
19759 if (zend_hash_num_elements(properties) == 0) {
19760 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
19761
19762 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
19763 }
19764
19765 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
19766
19767 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19768 } else {
19769 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
19770 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19771 if (UNEXPECTED(EG(exception))) {
19772 HANDLE_EXCEPTION();
19773 } else if (is_empty) {
19774 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
19775 } else {
19776 ZEND_VM_NEXT_OPCODE();
19777 }
19778 }
19779 } else {
19780 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
19781 ZVAL_UNDEF(EX_VAR(opline->result.var));
19782 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
19783 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19784 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
19785 }
19786 }
19787
ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19788 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19789 {
19790 USE_OPLINE
19791
19792 if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))
19793 && !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) {
19794 EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var));
19795 }
19796 ZEND_VM_NEXT_OPCODE();
19797 }
19798
ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19799 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19800 {
19801 USE_OPLINE
19802 zval *value;
19803 zend_reference *ref = NULL;
19804 bool ret;
19805
19806 SAVE_OPLINE();
19807 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19808
19809 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) {
19810 if (IS_TMP_VAR == IS_VAR) {
19811 ref = Z_REF_P(value);
19812 }
19813 value = Z_REFVAL_P(value);
19814 }
19815
19816 ret = i_zend_is_true(value);
19817
19818 if (UNEXPECTED(EG(exception))) {
19819 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19820 ZVAL_UNDEF(EX_VAR(opline->result.var));
19821 HANDLE_EXCEPTION();
19822 }
19823
19824 if (ret) {
19825 zval *result = EX_VAR(opline->result.var);
19826
19827 ZVAL_COPY_VALUE(result, value);
19828 if (IS_TMP_VAR == IS_CONST) {
19829 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
19830 } else if (IS_TMP_VAR == IS_CV) {
19831 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
19832 } else if (IS_TMP_VAR == IS_VAR && ref) {
19833 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19834 efree_size(ref, sizeof(zend_reference));
19835 } else if (Z_OPT_REFCOUNTED_P(result)) {
19836 Z_ADDREF_P(result);
19837 }
19838 }
19839 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
19840 }
19841
19842 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19843 ZEND_VM_NEXT_OPCODE();
19844 }
19845
ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19846 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19847 {
19848 USE_OPLINE
19849 zval *value;
19850 zend_reference *ref = NULL;
19851
19852 SAVE_OPLINE();
19853 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19854
19855 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
19856 if (IS_TMP_VAR & IS_VAR) {
19857 ref = Z_REF_P(value);
19858 }
19859 value = Z_REFVAL_P(value);
19860 }
19861
19862 if (Z_TYPE_P(value) > IS_NULL) {
19863 zval *result = EX_VAR(opline->result.var);
19864 ZVAL_COPY_VALUE(result, value);
19865 if (IS_TMP_VAR == IS_CONST) {
19866 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
19867 } else if (IS_TMP_VAR == IS_CV) {
19868 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
19869 } else if ((IS_TMP_VAR & IS_VAR) && ref) {
19870 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19871 efree_size(ref, sizeof(zend_reference));
19872 } else if (Z_OPT_REFCOUNTED_P(result)) {
19873 Z_ADDREF_P(result);
19874 }
19875 }
19876 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
19877 }
19878
19879 if ((IS_TMP_VAR & IS_VAR) && ref) {
19880 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19881 efree_size(ref, sizeof(zend_reference));
19882 }
19883 }
19884 ZEND_VM_NEXT_OPCODE();
19885 }
19886
ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19887 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19888 {
19889 USE_OPLINE
19890 zval *val, *result;
19891
19892 val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19893
19894 if (Z_TYPE_P(val) > IS_NULL) {
19895 do {
19896 if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
19897 val = Z_REFVAL_P(val);
19898 if (Z_TYPE_P(val) <= IS_NULL) {
19899 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19900 break;
19901 }
19902 }
19903 ZEND_VM_NEXT_OPCODE();
19904 } while (0);
19905 }
19906
19907 result = EX_VAR(opline->result.var);
19908 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
19909 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
19910 ZVAL_NULL(result);
19911 if (IS_TMP_VAR == IS_CV
19912 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
19913 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
19914 ) {
19915 SAVE_OPLINE();
19916 ZVAL_UNDEFINED_OP1();
19917 if (UNEXPECTED(EG(exception) != NULL)) {
19918 HANDLE_EXCEPTION();
19919 }
19920 }
19921 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
19922 ZVAL_FALSE(result);
19923 } else {
19924 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
19925 ZVAL_TRUE(result);
19926 }
19927
19928 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
19929 }
19930
ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19931 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19932 {
19933 USE_OPLINE
19934 zval *value;
19935 zval *result = EX_VAR(opline->result.var);
19936
19937 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19938 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
19939 SAVE_OPLINE();
19940 ZVAL_UNDEFINED_OP1();
19941 ZVAL_NULL(result);
19942 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19943 }
19944
19945 if (IS_TMP_VAR == IS_CV) {
19946 ZVAL_COPY_DEREF(result, value);
19947 } else if (IS_TMP_VAR == IS_VAR) {
19948 if (UNEXPECTED(Z_ISREF_P(value))) {
19949 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
19950 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
19951 efree_size(Z_REF_P(value), sizeof(zend_reference));
19952 } else if (Z_OPT_REFCOUNTED_P(result)) {
19953 Z_ADDREF_P(result);
19954 }
19955 } else {
19956 ZVAL_COPY_VALUE(result, value);
19957 }
19958 } else {
19959 ZVAL_COPY_VALUE(result, value);
19960 if (IS_TMP_VAR == IS_CONST) {
19961 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
19962 Z_ADDREF_P(result);
19963 }
19964 }
19965 }
19966 ZEND_VM_NEXT_OPCODE();
19967 }
19968
ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19969 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19970 {
19971 USE_OPLINE
19972 zval *op1, *op2;
19973 bool result;
19974
19975 SAVE_OPLINE();
19976 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19977 op2 = RT_CONSTANT(opline, opline->op2);
19978 result = fast_is_identical_function(op1, op2);
19979 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19980
19981 ZEND_VM_SMART_BRANCH(result, 1);
19982 }
19983
ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19984 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19985 {
19986 USE_OPLINE
19987 zval *op1, *op2;
19988 bool result;
19989
19990 SAVE_OPLINE();
19991 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19992 op2 = RT_CONSTANT(opline, opline->op2);
19993 result = fast_is_identical_function(op1, op2);
19994
19995 ZEND_VM_SMART_BRANCH(result, 1);
19996 }
19997
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19998 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19999 {
20000 USE_OPLINE
20001 zval *op1, *op2;
20002 bool result;
20003
20004 SAVE_OPLINE();
20005 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20006 op2 = RT_CONSTANT(opline, opline->op2);
20007 result = fast_is_not_identical_function(op1, op2);
20008 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20009
20010 ZEND_VM_SMART_BRANCH(result, 1);
20011 }
20012
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20013 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20014 {
20015 #if 0
20016 USE_OPLINE
20017 #endif
20018
20019 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20020 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20021 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20022 }
20023 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20024 } else {
20025 if (IS_CONST == IS_UNUSED) {
20026 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20027 }
20028 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20029 }
20030 }
20031
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20032 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20033 {
20034 #if 0
20035 USE_OPLINE
20036 #endif
20037
20038 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20039 /* Behave like FETCH_OBJ_W */
20040 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20041 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20042 }
20043 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20044 } else {
20045 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20046 }
20047 }
20048
ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20049 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20050 {
20051 USE_OPLINE
20052 zend_string **rope;
20053 zval *var;
20054
20055 /* op1 and result are the same */
20056 rope = (zend_string**)EX_VAR(opline->op1.var);
20057 if (IS_CONST == IS_CONST) {
20058 var = RT_CONSTANT(opline, opline->op2);
20059 rope[opline->extended_value] = Z_STR_P(var);
20060 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20061 Z_ADDREF_P(var);
20062 }
20063 } else {
20064 var = RT_CONSTANT(opline, opline->op2);
20065 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20066 if (IS_CONST == IS_CV) {
20067 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20068 } else {
20069 rope[opline->extended_value] = Z_STR_P(var);
20070 }
20071 } else {
20072 SAVE_OPLINE();
20073 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20074 ZVAL_UNDEFINED_OP2();
20075 }
20076 rope[opline->extended_value] = zval_get_string_func(var);
20077
20078 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20079 }
20080 }
20081 ZEND_VM_NEXT_OPCODE();
20082 }
20083
ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20084 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20085 {
20086 USE_OPLINE
20087 zend_string **rope;
20088 zval *var, *ret;
20089 uint32_t i;
20090
20091 rope = (zend_string**)EX_VAR(opline->op1.var);
20092 if (IS_CONST == IS_CONST) {
20093 var = RT_CONSTANT(opline, opline->op2);
20094 rope[opline->extended_value] = Z_STR_P(var);
20095 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20096 Z_ADDREF_P(var);
20097 }
20098 } else {
20099 var = RT_CONSTANT(opline, opline->op2);
20100 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20101 if (IS_CONST == IS_CV) {
20102 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20103 } else {
20104 rope[opline->extended_value] = Z_STR_P(var);
20105 }
20106 } else {
20107 SAVE_OPLINE();
20108 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20109 ZVAL_UNDEFINED_OP2();
20110 }
20111 rope[opline->extended_value] = zval_get_string_func(var);
20112
20113 if (UNEXPECTED(EG(exception))) {
20114 for (i = 0; i <= opline->extended_value; i++) {
20115 zend_string_release_ex(rope[i], 0);
20116 }
20117 ZVAL_UNDEF(EX_VAR(opline->result.var));
20118 HANDLE_EXCEPTION();
20119 }
20120 }
20121 }
20122
20123 size_t len = 0;
20124 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
20125 for (i = 0; i <= opline->extended_value; i++) {
20126 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
20127 len += ZSTR_LEN(rope[i]);
20128 }
20129 ret = EX_VAR(opline->result.var);
20130 ZVAL_STR(ret, zend_string_alloc(len, 0));
20131 GC_ADD_FLAGS(Z_STR_P(ret), flags);
20132
20133 char *target = Z_STRVAL_P(ret);
20134 for (i = 0; i <= opline->extended_value; i++) {
20135 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
20136 target += ZSTR_LEN(rope[i]);
20137 zend_string_release_ex(rope[i], 0);
20138 }
20139 *target = '\0';
20140
20141 ZEND_VM_NEXT_OPCODE();
20142 }
20143
ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20144 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20145 {
20146 USE_OPLINE
20147 zval *value, *arg;
20148 uint32_t arg_num;
20149
20150 if (IS_CONST == IS_CONST) {
20151 SAVE_OPLINE();
20152 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
20153 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
20154 if (UNEXPECTED(!arg)) {
20155 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20156 HANDLE_EXCEPTION();
20157 }
20158 } else {
20159 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
20160 arg_num = opline->op2.num;
20161 }
20162
20163 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
20164 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20165 goto send_val_by_ref;
20166 }
20167 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20168 send_val_by_ref:
20169 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
20170 }
20171 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20172 ZVAL_COPY_VALUE(arg, value);
20173 if (IS_TMP_VAR == IS_CONST) {
20174 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
20175 Z_ADDREF_P(arg);
20176 }
20177 }
20178 ZEND_VM_NEXT_OPCODE();
20179 }
20180
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20181 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20182 {
20183 USE_OPLINE
20184 zval *expr_ptr, new_expr;
20185
20186 SAVE_OPLINE();
20187 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
20188 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
20189 expr_ptr = zend_get_bad_ptr();
20190 if (Z_ISREF_P(expr_ptr)) {
20191 Z_ADDREF_P(expr_ptr);
20192 } else {
20193 ZVAL_MAKE_REF_EX(expr_ptr, 2);
20194 }
20195 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20196 } else {
20197 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20198 if (IS_TMP_VAR == IS_TMP_VAR) {
20199 /* pass */
20200 } else if (IS_TMP_VAR == IS_CONST) {
20201 Z_TRY_ADDREF_P(expr_ptr);
20202 } else if (IS_TMP_VAR == IS_CV) {
20203 ZVAL_DEREF(expr_ptr);
20204 Z_TRY_ADDREF_P(expr_ptr);
20205 } else /* if (IS_TMP_VAR == IS_VAR) */ {
20206 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
20207 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
20208
20209 expr_ptr = Z_REFVAL_P(expr_ptr);
20210 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20211 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
20212 expr_ptr = &new_expr;
20213 efree_size(ref, sizeof(zend_reference));
20214 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
20215 Z_ADDREF_P(expr_ptr);
20216 }
20217 }
20218 }
20219 }
20220
20221 if (IS_CONST != IS_UNUSED) {
20222 zval *offset = RT_CONSTANT(opline, opline->op2);
20223 zend_string *str;
20224 zend_ulong hval;
20225
20226 add_again:
20227 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
20228 str = Z_STR_P(offset);
20229 if (IS_CONST != IS_CONST) {
20230 if (ZEND_HANDLE_NUMERIC(str, hval)) {
20231 goto num_index;
20232 }
20233 }
20234 str_index:
20235 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
20236 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
20237 hval = Z_LVAL_P(offset);
20238 num_index:
20239 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
20240 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
20241 offset = Z_REFVAL_P(offset);
20242 goto add_again;
20243 } else if (Z_TYPE_P(offset) == IS_NULL) {
20244 str = ZSTR_EMPTY_ALLOC();
20245 goto str_index;
20246 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
20247 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
20248 goto num_index;
20249 } else if (Z_TYPE_P(offset) == IS_FALSE) {
20250 hval = 0;
20251 goto num_index;
20252 } else if (Z_TYPE_P(offset) == IS_TRUE) {
20253 hval = 1;
20254 goto num_index;
20255 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
20256 zend_use_resource_as_offset(offset);
20257 hval = Z_RES_HANDLE_P(offset);
20258 goto num_index;
20259 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
20260 ZVAL_UNDEFINED_OP2();
20261 str = ZSTR_EMPTY_ALLOC();
20262 goto str_index;
20263 } else {
20264 zend_illegal_array_offset_access(offset);
20265 zval_ptr_dtor_nogc(expr_ptr);
20266 }
20267
20268 } else {
20269 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
20270 zend_cannot_add_element();
20271 zval_ptr_dtor_nogc(expr_ptr);
20272 }
20273 }
20274 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20275 }
20276
ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20277 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20278 {
20279 zval *array;
20280 uint32_t size;
20281 USE_OPLINE
20282
20283 array = EX_VAR(opline->result.var);
20284 if (IS_TMP_VAR != IS_UNUSED) {
20285 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
20286 ZVAL_ARR(array, zend_new_array(size));
20287 /* Explicitly initialize array as not-packed if flag is set */
20288 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
20289 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
20290 }
20291 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20292 } else {
20293 ZVAL_ARR(array, zend_new_array(0));
20294 ZEND_VM_NEXT_OPCODE();
20295 }
20296 }
20297
ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20298 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20299 {
20300 USE_OPLINE
20301
20302 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
20303
20304 SAVE_OPLINE();
20305 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
20306 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20307 }
20308
20309 /* Destroy the previously yielded value */
20310 zval_ptr_dtor(&generator->value);
20311
20312 /* Destroy the previously yielded key */
20313 zval_ptr_dtor(&generator->key);
20314
20315 /* Set the new yielded value */
20316 if (IS_TMP_VAR != IS_UNUSED) {
20317 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
20318 /* Constants and temporary variables aren't yieldable by reference,
20319 * but we still allow them with a notice. */
20320 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
20321 zval *value;
20322
20323 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20324
20325 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20326 ZVAL_COPY_VALUE(&generator->value, value);
20327 if (IS_TMP_VAR == IS_CONST) {
20328 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20329 Z_ADDREF(generator->value);
20330 }
20331 }
20332 } else {
20333 zval *value_ptr = zend_get_bad_ptr();
20334
20335 /* If a function call result is yielded and the function did
20336 * not return by reference we throw a notice. */
20337 do {
20338 if (IS_TMP_VAR == IS_VAR) {
20339 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
20340 if (opline->extended_value == ZEND_RETURNS_FUNCTION
20341 && !Z_ISREF_P(value_ptr)) {
20342 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20343 ZVAL_COPY(&generator->value, value_ptr);
20344 break;
20345 }
20346 }
20347 if (Z_ISREF_P(value_ptr)) {
20348 Z_ADDREF_P(value_ptr);
20349 } else {
20350 ZVAL_MAKE_REF_EX(value_ptr, 2);
20351 }
20352 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
20353 } while (0);
20354
20355 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20356 }
20357 } else {
20358 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20359
20360 /* Consts, temporary variables and references need copying */
20361 if (IS_TMP_VAR == IS_CONST) {
20362 ZVAL_COPY_VALUE(&generator->value, value);
20363 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20364 Z_ADDREF(generator->value);
20365 }
20366 } else if (IS_TMP_VAR == IS_TMP_VAR) {
20367 ZVAL_COPY_VALUE(&generator->value, value);
20368 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
20369 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
20370
20371 } else {
20372 ZVAL_COPY_VALUE(&generator->value, value);
20373 if (IS_TMP_VAR == IS_CV) {
20374 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
20375 }
20376 }
20377 }
20378 } else {
20379 /* If no value was specified yield null */
20380 ZVAL_NULL(&generator->value);
20381 }
20382
20383 /* Set the new yielded key */
20384 if (IS_CONST != IS_UNUSED) {
20385 zval *key = RT_CONSTANT(opline, opline->op2);
20386 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
20387 key = Z_REFVAL_P(key);
20388 }
20389 ZVAL_COPY(&generator->key, key);
20390
20391 if (Z_TYPE(generator->key) == IS_LONG
20392 && Z_LVAL(generator->key) > generator->largest_used_integer_key
20393 ) {
20394 generator->largest_used_integer_key = Z_LVAL(generator->key);
20395 }
20396 } else {
20397 /* If no key was specified we use auto-increment keys */
20398 generator->largest_used_integer_key++;
20399 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
20400 }
20401
20402 if (RETURN_VALUE_USED(opline)) {
20403 /* If the return value of yield is used set the send
20404 * target and initialize it to NULL */
20405 generator->send_target = EX_VAR(opline->result.var);
20406 ZVAL_NULL(generator->send_target);
20407 } else {
20408 generator->send_target = NULL;
20409 }
20410
20411 /* We increment to the next op, so we are at the correct position when the
20412 * generator is resumed. */
20413 ZEND_VM_INC_OPCODE();
20414
20415 /* The GOTO VM uses a local opline variable. We need to set the opline
20416 * variable in execute_data so we don't resume at an old position. */
20417 SAVE_OPLINE();
20418
20419 ZEND_VM_RETURN();
20420 }
20421
ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20422 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20423 {
20424 USE_OPLINE
20425 zval *op1;
20426 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
20427 zval *result;
20428
20429 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20430 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20431 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_TMP_VAR == IS_CONST);
20432 if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) {
20433 zval_ptr_dtor_str(op1);
20434 }
20435 ZEND_VM_SMART_BRANCH(result, 0);
20436 }
20437
20438 if (opline->extended_value) {
20439 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
20440 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
20441 ZEND_VM_SMART_BRANCH(result, 0);
20442 }
20443 SAVE_OPLINE();
20444 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
20445 op1 = Z_REFVAL_P(op1);
20446 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20447 result = zend_hash_find(ht, Z_STR_P(op1));
20448 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20449 ZEND_VM_SMART_BRANCH(result, 0);
20450 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
20451 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
20452 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20453 ZEND_VM_SMART_BRANCH(result, 0);
20454 }
20455 } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
20456 ZVAL_UNDEFINED_OP1();
20457 }
20458 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
20459 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
20460 SAVE_OPLINE();
20461 ZVAL_UNDEFINED_OP1();
20462 if (UNEXPECTED(EG(exception) != NULL)) {
20463 HANDLE_EXCEPTION();
20464 }
20465 }
20466 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
20467 ZEND_VM_SMART_BRANCH(result, 0);
20468 } else {
20469 zend_string *key;
20470 zval key_tmp;
20471
20472 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
20473 op1 = Z_REFVAL_P(op1);
20474 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20475 result = zend_hash_find(ht, Z_STR_P(op1));
20476 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20477 ZEND_VM_SMART_BRANCH(result, 0);
20478 }
20479 }
20480
20481 SAVE_OPLINE();
20482 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
20483 ZVAL_STR(&key_tmp, key);
20484 if (zend_compare(op1, &key_tmp) == 0) {
20485 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20486 ZEND_VM_SMART_BRANCH(1, 1);
20487 }
20488 } ZEND_HASH_FOREACH_END();
20489 }
20490 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20491 ZEND_VM_SMART_BRANCH(0, 1);
20492 }
20493
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20494 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20495 {
20496 #if 0
20497 USE_OPLINE
20498 #endif
20499
20500 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20501 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20502 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20503 }
20504 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20505 } else {
20506 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
20507 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20508 }
20509 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20510 }
20511 }
20512
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20513 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20514 {
20515 #if 0
20516 USE_OPLINE
20517 #endif
20518
20519 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20520 /* Behave like FETCH_OBJ_W */
20521 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20522 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20523 }
20524 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20525 } else {
20526 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20527 }
20528 }
20529
ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20530 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20531 {
20532 USE_OPLINE
20533 zend_string **rope;
20534 zval *var;
20535
20536 /* op1 and result are the same */
20537 rope = (zend_string**)EX_VAR(opline->op1.var);
20538 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
20539 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20540 rope[opline->extended_value] = Z_STR_P(var);
20541 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20542 Z_ADDREF_P(var);
20543 }
20544 } else {
20545 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20546 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20547 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
20548 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20549 } else {
20550 rope[opline->extended_value] = Z_STR_P(var);
20551 }
20552 } else {
20553 SAVE_OPLINE();
20554 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20555 ZVAL_UNDEFINED_OP2();
20556 }
20557 rope[opline->extended_value] = zval_get_string_func(var);
20558 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20559 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20560 }
20561 }
20562 ZEND_VM_NEXT_OPCODE();
20563 }
20564
ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20565 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20566 {
20567 USE_OPLINE
20568 zend_string **rope;
20569 zval *var, *ret;
20570 uint32_t i;
20571
20572 rope = (zend_string**)EX_VAR(opline->op1.var);
20573 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
20574 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20575 rope[opline->extended_value] = Z_STR_P(var);
20576 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20577 Z_ADDREF_P(var);
20578 }
20579 } else {
20580 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20581 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20582 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
20583 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20584 } else {
20585 rope[opline->extended_value] = Z_STR_P(var);
20586 }
20587 } else {
20588 SAVE_OPLINE();
20589 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20590 ZVAL_UNDEFINED_OP2();
20591 }
20592 rope[opline->extended_value] = zval_get_string_func(var);
20593 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20594 if (UNEXPECTED(EG(exception))) {
20595 for (i = 0; i <= opline->extended_value; i++) {
20596 zend_string_release_ex(rope[i], 0);
20597 }
20598 ZVAL_UNDEF(EX_VAR(opline->result.var));
20599 HANDLE_EXCEPTION();
20600 }
20601 }
20602 }
20603
20604 size_t len = 0;
20605 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
20606 for (i = 0; i <= opline->extended_value; i++) {
20607 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
20608 len += ZSTR_LEN(rope[i]);
20609 }
20610 ret = EX_VAR(opline->result.var);
20611 ZVAL_STR(ret, zend_string_alloc(len, 0));
20612 GC_ADD_FLAGS(Z_STR_P(ret), flags);
20613
20614 char *target = Z_STRVAL_P(ret);
20615 for (i = 0; i <= opline->extended_value; i++) {
20616 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
20617 target += ZSTR_LEN(rope[i]);
20618 zend_string_release_ex(rope[i], 0);
20619 }
20620 *target = '\0';
20621
20622 ZEND_VM_NEXT_OPCODE();
20623 }
20624
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20625 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20626 {
20627 USE_OPLINE
20628 zval *expr_ptr, new_expr;
20629
20630 SAVE_OPLINE();
20631 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
20632 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
20633 expr_ptr = zend_get_bad_ptr();
20634 if (Z_ISREF_P(expr_ptr)) {
20635 Z_ADDREF_P(expr_ptr);
20636 } else {
20637 ZVAL_MAKE_REF_EX(expr_ptr, 2);
20638 }
20639 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20640 } else {
20641 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20642 if (IS_TMP_VAR == IS_TMP_VAR) {
20643 /* pass */
20644 } else if (IS_TMP_VAR == IS_CONST) {
20645 Z_TRY_ADDREF_P(expr_ptr);
20646 } else if (IS_TMP_VAR == IS_CV) {
20647 ZVAL_DEREF(expr_ptr);
20648 Z_TRY_ADDREF_P(expr_ptr);
20649 } else /* if (IS_TMP_VAR == IS_VAR) */ {
20650 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
20651 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
20652
20653 expr_ptr = Z_REFVAL_P(expr_ptr);
20654 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20655 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
20656 expr_ptr = &new_expr;
20657 efree_size(ref, sizeof(zend_reference));
20658 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
20659 Z_ADDREF_P(expr_ptr);
20660 }
20661 }
20662 }
20663 }
20664
20665 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
20666 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20667 zend_string *str;
20668 zend_ulong hval;
20669
20670 add_again:
20671 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
20672 str = Z_STR_P(offset);
20673 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
20674 if (ZEND_HANDLE_NUMERIC(str, hval)) {
20675 goto num_index;
20676 }
20677 }
20678 str_index:
20679 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
20680 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
20681 hval = Z_LVAL_P(offset);
20682 num_index:
20683 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
20684 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
20685 offset = Z_REFVAL_P(offset);
20686 goto add_again;
20687 } else if (Z_TYPE_P(offset) == IS_NULL) {
20688 str = ZSTR_EMPTY_ALLOC();
20689 goto str_index;
20690 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
20691 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
20692 goto num_index;
20693 } else if (Z_TYPE_P(offset) == IS_FALSE) {
20694 hval = 0;
20695 goto num_index;
20696 } else if (Z_TYPE_P(offset) == IS_TRUE) {
20697 hval = 1;
20698 goto num_index;
20699 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
20700 zend_use_resource_as_offset(offset);
20701 hval = Z_RES_HANDLE_P(offset);
20702 goto num_index;
20703 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
20704 ZVAL_UNDEFINED_OP2();
20705 str = ZSTR_EMPTY_ALLOC();
20706 goto str_index;
20707 } else {
20708 zend_illegal_array_offset_access(offset);
20709 zval_ptr_dtor_nogc(expr_ptr);
20710 }
20711 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20712 } else {
20713 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
20714 zend_cannot_add_element();
20715 zval_ptr_dtor_nogc(expr_ptr);
20716 }
20717 }
20718 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20719 }
20720
ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20721 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20722 {
20723 zval *array;
20724 uint32_t size;
20725 USE_OPLINE
20726
20727 array = EX_VAR(opline->result.var);
20728 if (IS_TMP_VAR != IS_UNUSED) {
20729 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
20730 ZVAL_ARR(array, zend_new_array(size));
20731 /* Explicitly initialize array as not-packed if flag is set */
20732 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
20733 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
20734 }
20735 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20736 } else {
20737 ZVAL_ARR(array, zend_new_array(0));
20738 ZEND_VM_NEXT_OPCODE();
20739 }
20740 }
20741
ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20742 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20743 {
20744 USE_OPLINE
20745
20746 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
20747
20748 SAVE_OPLINE();
20749 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
20750 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20751 }
20752
20753 /* Destroy the previously yielded value */
20754 zval_ptr_dtor(&generator->value);
20755
20756 /* Destroy the previously yielded key */
20757 zval_ptr_dtor(&generator->key);
20758
20759 /* Set the new yielded value */
20760 if (IS_TMP_VAR != IS_UNUSED) {
20761 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
20762 /* Constants and temporary variables aren't yieldable by reference,
20763 * but we still allow them with a notice. */
20764 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
20765 zval *value;
20766
20767 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20768
20769 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20770 ZVAL_COPY_VALUE(&generator->value, value);
20771 if (IS_TMP_VAR == IS_CONST) {
20772 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20773 Z_ADDREF(generator->value);
20774 }
20775 }
20776 } else {
20777 zval *value_ptr = zend_get_bad_ptr();
20778
20779 /* If a function call result is yielded and the function did
20780 * not return by reference we throw a notice. */
20781 do {
20782 if (IS_TMP_VAR == IS_VAR) {
20783 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
20784 if (opline->extended_value == ZEND_RETURNS_FUNCTION
20785 && !Z_ISREF_P(value_ptr)) {
20786 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20787 ZVAL_COPY(&generator->value, value_ptr);
20788 break;
20789 }
20790 }
20791 if (Z_ISREF_P(value_ptr)) {
20792 Z_ADDREF_P(value_ptr);
20793 } else {
20794 ZVAL_MAKE_REF_EX(value_ptr, 2);
20795 }
20796 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
20797 } while (0);
20798
20799 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20800 }
20801 } else {
20802 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20803
20804 /* Consts, temporary variables and references need copying */
20805 if (IS_TMP_VAR == IS_CONST) {
20806 ZVAL_COPY_VALUE(&generator->value, value);
20807 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20808 Z_ADDREF(generator->value);
20809 }
20810 } else if (IS_TMP_VAR == IS_TMP_VAR) {
20811 ZVAL_COPY_VALUE(&generator->value, value);
20812 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
20813 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
20814
20815 } else {
20816 ZVAL_COPY_VALUE(&generator->value, value);
20817 if (IS_TMP_VAR == IS_CV) {
20818 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
20819 }
20820 }
20821 }
20822 } else {
20823 /* If no value was specified yield null */
20824 ZVAL_NULL(&generator->value);
20825 }
20826
20827 /* Set the new yielded key */
20828 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
20829 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20830 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
20831 key = Z_REFVAL_P(key);
20832 }
20833 ZVAL_COPY(&generator->key, key);
20834 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20835
20836 if (Z_TYPE(generator->key) == IS_LONG
20837 && Z_LVAL(generator->key) > generator->largest_used_integer_key
20838 ) {
20839 generator->largest_used_integer_key = Z_LVAL(generator->key);
20840 }
20841 } else {
20842 /* If no key was specified we use auto-increment keys */
20843 generator->largest_used_integer_key++;
20844 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
20845 }
20846
20847 if (RETURN_VALUE_USED(opline)) {
20848 /* If the return value of yield is used set the send
20849 * target and initialize it to NULL */
20850 generator->send_target = EX_VAR(opline->result.var);
20851 ZVAL_NULL(generator->send_target);
20852 } else {
20853 generator->send_target = NULL;
20854 }
20855
20856 /* We increment to the next op, so we are at the correct position when the
20857 * generator is resumed. */
20858 ZEND_VM_INC_OPCODE();
20859
20860 /* The GOTO VM uses a local opline variable. We need to set the opline
20861 * variable in execute_data so we don't resume at an old position. */
20862 SAVE_OPLINE();
20863
20864 ZEND_VM_RETURN();
20865 }
20866
ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20867 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20868 {
20869 USE_OPLINE
20870 zval *op1, *op2;
20871 bool result;
20872
20873 SAVE_OPLINE();
20874 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20875 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
20876 result = fast_is_identical_function(op1, op2);
20877 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20878 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20879 ZEND_VM_SMART_BRANCH(result, 1);
20880 }
20881
ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20882 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20883 {
20884 USE_OPLINE
20885 zval *op1, *op2;
20886 bool result;
20887
20888 SAVE_OPLINE();
20889 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20890 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
20891 result = fast_is_identical_function(op1, op2);
20892 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20893 ZEND_VM_SMART_BRANCH(result, 1);
20894 }
20895
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20896 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20897 {
20898 USE_OPLINE
20899 zval *op1, *op2;
20900 bool result;
20901
20902 SAVE_OPLINE();
20903 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20904 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
20905 result = fast_is_not_identical_function(op1, op2);
20906 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20907 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20908 ZEND_VM_SMART_BRANCH(result, 1);
20909 }
20910
ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20911 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20912 {
20913 USE_OPLINE
20914 zval *op1, *op2;
20915 bool result;
20916
20917 SAVE_OPLINE();
20918 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20919 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
20920 result = fast_is_identical_function(op1, op2);
20921 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20922 ZEND_VM_SMART_BRANCH(result, 1);
20923 }
20924
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20925 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20926 {
20927 #if 0
20928 USE_OPLINE
20929 #endif
20930
20931 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20932 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20933 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20934 }
20935 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20936 } else {
20937 if (IS_UNUSED == IS_UNUSED) {
20938 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20939 }
20940 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20941 }
20942 }
20943
ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20944 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20945 {
20946 if (IS_TMP_VAR == IS_UNUSED) {
20947 SAVE_OPLINE();
20948 zend_verify_missing_return_type(EX(func));
20949 HANDLE_EXCEPTION();
20950 } else {
20951 /* prevents "undefined variable opline" errors */
20952 #if 0 || (IS_TMP_VAR != IS_UNUSED)
20953 USE_OPLINE
20954 zval *retval_ref, *retval_ptr;
20955 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
20956 retval_ref = retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20957
20958 if (IS_TMP_VAR == IS_CONST) {
20959 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
20960 retval_ref = retval_ptr = EX_VAR(opline->result.var);
20961 } else if (IS_TMP_VAR == IS_VAR) {
20962 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
20963 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
20964 }
20965 ZVAL_DEREF(retval_ptr);
20966 } else if (IS_TMP_VAR == IS_CV) {
20967 ZVAL_DEREF(retval_ptr);
20968 }
20969
20970 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
20971 ZEND_VM_NEXT_OPCODE();
20972 }
20973
20974 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
20975 SAVE_OPLINE();
20976 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
20977 if (UNEXPECTED(EG(exception))) {
20978 HANDLE_EXCEPTION();
20979 }
20980 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
20981 ZEND_VM_NEXT_OPCODE();
20982 }
20983 }
20984
20985 zend_reference *ref = NULL;
20986 void *cache_slot = CACHE_ADDR(opline->op2.num);
20987 if (UNEXPECTED(retval_ref != retval_ptr)) {
20988 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
20989 ref = Z_REF_P(retval_ref);
20990 } else {
20991 /* A cast might happen - unwrap the reference if this is a by-value return */
20992 if (Z_REFCOUNT_P(retval_ref) == 1) {
20993 ZVAL_UNREF(retval_ref);
20994 } else {
20995 Z_DELREF_P(retval_ref);
20996 ZVAL_COPY(retval_ref, retval_ptr);
20997 }
20998 retval_ptr = retval_ref;
20999 }
21000 }
21001
21002 SAVE_OPLINE();
21003 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
21004 zend_verify_return_error(EX(func), retval_ptr);
21005 HANDLE_EXCEPTION();
21006 }
21007 ZEND_VM_NEXT_OPCODE();
21008 #endif
21009 }
21010 }
21011
ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21012 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21013 {
21014 USE_OPLINE
21015 zval *value, *arg;
21016 uint32_t arg_num;
21017
21018 if (IS_UNUSED == IS_CONST) {
21019 SAVE_OPLINE();
21020 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21021 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21022 if (UNEXPECTED(!arg)) {
21023 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21024 HANDLE_EXCEPTION();
21025 }
21026 } else {
21027 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21028 arg_num = opline->op2.num;
21029 }
21030
21031 if (EXPECTED(0)) {
21032 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21033 goto send_val_by_ref;
21034 }
21035 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21036 send_val_by_ref:
21037 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
21038 }
21039 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21040 ZVAL_COPY_VALUE(arg, value);
21041 if (IS_TMP_VAR == IS_CONST) {
21042 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21043 Z_ADDREF_P(arg);
21044 }
21045 }
21046 ZEND_VM_NEXT_OPCODE();
21047 }
21048
ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21049 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21050 {
21051 USE_OPLINE
21052 zval *value, *arg;
21053 uint32_t arg_num;
21054
21055 if (IS_UNUSED == IS_CONST) {
21056 SAVE_OPLINE();
21057 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21058 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21059 if (UNEXPECTED(!arg)) {
21060 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21061 HANDLE_EXCEPTION();
21062 }
21063 } else {
21064 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21065 arg_num = opline->op2.num;
21066 }
21067
21068 if (EXPECTED(1)) {
21069 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21070 goto send_val_by_ref;
21071 }
21072 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21073 send_val_by_ref:
21074 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
21075 }
21076 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21077 ZVAL_COPY_VALUE(arg, value);
21078 if (IS_TMP_VAR == IS_CONST) {
21079 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21080 Z_ADDREF_P(arg);
21081 }
21082 }
21083 ZEND_VM_NEXT_OPCODE();
21084 }
21085
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21086 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21087 {
21088 USE_OPLINE
21089 zval *expr_ptr, new_expr;
21090
21091 SAVE_OPLINE();
21092 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21093 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21094 expr_ptr = zend_get_bad_ptr();
21095 if (Z_ISREF_P(expr_ptr)) {
21096 Z_ADDREF_P(expr_ptr);
21097 } else {
21098 ZVAL_MAKE_REF_EX(expr_ptr, 2);
21099 }
21100 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21101 } else {
21102 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21103 if (IS_TMP_VAR == IS_TMP_VAR) {
21104 /* pass */
21105 } else if (IS_TMP_VAR == IS_CONST) {
21106 Z_TRY_ADDREF_P(expr_ptr);
21107 } else if (IS_TMP_VAR == IS_CV) {
21108 ZVAL_DEREF(expr_ptr);
21109 Z_TRY_ADDREF_P(expr_ptr);
21110 } else /* if (IS_TMP_VAR == IS_VAR) */ {
21111 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21112 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21113
21114 expr_ptr = Z_REFVAL_P(expr_ptr);
21115 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21116 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21117 expr_ptr = &new_expr;
21118 efree_size(ref, sizeof(zend_reference));
21119 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21120 Z_ADDREF_P(expr_ptr);
21121 }
21122 }
21123 }
21124 }
21125
21126 if (IS_UNUSED != IS_UNUSED) {
21127 zval *offset = NULL;
21128 zend_string *str;
21129 zend_ulong hval;
21130
21131 add_again:
21132 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21133 str = Z_STR_P(offset);
21134 if (IS_UNUSED != IS_CONST) {
21135 if (ZEND_HANDLE_NUMERIC(str, hval)) {
21136 goto num_index;
21137 }
21138 }
21139 str_index:
21140 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21141 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21142 hval = Z_LVAL_P(offset);
21143 num_index:
21144 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21145 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21146 offset = Z_REFVAL_P(offset);
21147 goto add_again;
21148 } else if (Z_TYPE_P(offset) == IS_NULL) {
21149 str = ZSTR_EMPTY_ALLOC();
21150 goto str_index;
21151 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21152 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21153 goto num_index;
21154 } else if (Z_TYPE_P(offset) == IS_FALSE) {
21155 hval = 0;
21156 goto num_index;
21157 } else if (Z_TYPE_P(offset) == IS_TRUE) {
21158 hval = 1;
21159 goto num_index;
21160 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21161 zend_use_resource_as_offset(offset);
21162 hval = Z_RES_HANDLE_P(offset);
21163 goto num_index;
21164 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21165 ZVAL_UNDEFINED_OP2();
21166 str = ZSTR_EMPTY_ALLOC();
21167 goto str_index;
21168 } else {
21169 zend_illegal_array_offset_access(offset);
21170 zval_ptr_dtor_nogc(expr_ptr);
21171 }
21172
21173 } else {
21174 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21175 zend_cannot_add_element();
21176 zval_ptr_dtor_nogc(expr_ptr);
21177 }
21178 }
21179 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21180 }
21181
ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21182 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21183 {
21184 zval *array;
21185 uint32_t size;
21186 USE_OPLINE
21187
21188 array = EX_VAR(opline->result.var);
21189 if (IS_TMP_VAR != IS_UNUSED) {
21190 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21191 ZVAL_ARR(array, zend_new_array(size));
21192 /* Explicitly initialize array as not-packed if flag is set */
21193 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21194 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21195 }
21196 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21197 } else {
21198 ZVAL_ARR(array, zend_new_array(0));
21199 ZEND_VM_NEXT_OPCODE();
21200 }
21201 }
21202
ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21203 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21204 {
21205 USE_OPLINE
21206
21207 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21208
21209 SAVE_OPLINE();
21210 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21211 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21212 }
21213
21214 /* Destroy the previously yielded value */
21215 zval_ptr_dtor(&generator->value);
21216
21217 /* Destroy the previously yielded key */
21218 zval_ptr_dtor(&generator->key);
21219
21220 /* Set the new yielded value */
21221 if (IS_TMP_VAR != IS_UNUSED) {
21222 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21223 /* Constants and temporary variables aren't yieldable by reference,
21224 * but we still allow them with a notice. */
21225 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21226 zval *value;
21227
21228 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21229
21230 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21231 ZVAL_COPY_VALUE(&generator->value, value);
21232 if (IS_TMP_VAR == IS_CONST) {
21233 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21234 Z_ADDREF(generator->value);
21235 }
21236 }
21237 } else {
21238 zval *value_ptr = zend_get_bad_ptr();
21239
21240 /* If a function call result is yielded and the function did
21241 * not return by reference we throw a notice. */
21242 do {
21243 if (IS_TMP_VAR == IS_VAR) {
21244 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21245 if (opline->extended_value == ZEND_RETURNS_FUNCTION
21246 && !Z_ISREF_P(value_ptr)) {
21247 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21248 ZVAL_COPY(&generator->value, value_ptr);
21249 break;
21250 }
21251 }
21252 if (Z_ISREF_P(value_ptr)) {
21253 Z_ADDREF_P(value_ptr);
21254 } else {
21255 ZVAL_MAKE_REF_EX(value_ptr, 2);
21256 }
21257 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21258 } while (0);
21259
21260 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21261 }
21262 } else {
21263 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21264
21265 /* Consts, temporary variables and references need copying */
21266 if (IS_TMP_VAR == IS_CONST) {
21267 ZVAL_COPY_VALUE(&generator->value, value);
21268 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21269 Z_ADDREF(generator->value);
21270 }
21271 } else if (IS_TMP_VAR == IS_TMP_VAR) {
21272 ZVAL_COPY_VALUE(&generator->value, value);
21273 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21274 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21275
21276 } else {
21277 ZVAL_COPY_VALUE(&generator->value, value);
21278 if (IS_TMP_VAR == IS_CV) {
21279 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21280 }
21281 }
21282 }
21283 } else {
21284 /* If no value was specified yield null */
21285 ZVAL_NULL(&generator->value);
21286 }
21287
21288 /* Set the new yielded key */
21289 if (IS_UNUSED != IS_UNUSED) {
21290 zval *key = NULL;
21291 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21292 key = Z_REFVAL_P(key);
21293 }
21294 ZVAL_COPY(&generator->key, key);
21295
21296 if (Z_TYPE(generator->key) == IS_LONG
21297 && Z_LVAL(generator->key) > generator->largest_used_integer_key
21298 ) {
21299 generator->largest_used_integer_key = Z_LVAL(generator->key);
21300 }
21301 } else {
21302 /* If no key was specified we use auto-increment keys */
21303 generator->largest_used_integer_key++;
21304 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21305 }
21306
21307 if (RETURN_VALUE_USED(opline)) {
21308 /* If the return value of yield is used set the send
21309 * target and initialize it to NULL */
21310 generator->send_target = EX_VAR(opline->result.var);
21311 ZVAL_NULL(generator->send_target);
21312 } else {
21313 generator->send_target = NULL;
21314 }
21315
21316 /* We increment to the next op, so we are at the correct position when the
21317 * generator is resumed. */
21318 ZEND_VM_INC_OPCODE();
21319
21320 /* The GOTO VM uses a local opline variable. We need to set the opline
21321 * variable in execute_data so we don't resume at an old position. */
21322 SAVE_OPLINE();
21323
21324 ZEND_VM_RETURN();
21325 }
21326
ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21327 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21328 {
21329 USE_OPLINE
21330 zval *op1;
21331 zend_string *type;
21332
21333 SAVE_OPLINE();
21334 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21335 type = zend_zval_get_legacy_type(op1);
21336 if (EXPECTED(type)) {
21337 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
21338 } else {
21339 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
21340 }
21341 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21342 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21343 }
21344
ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21345 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21346 {
21347 USE_OPLINE
21348 zval *op1, *op2;
21349 bool result;
21350
21351 SAVE_OPLINE();
21352 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21353 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21354 result = fast_is_identical_function(op1, op2);
21355
21356 ZEND_VM_SMART_BRANCH(result, 1);
21357 }
21358
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21359 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21360 {
21361 #if 0
21362 USE_OPLINE
21363 #endif
21364
21365 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21366 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21367 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21368 }
21369 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21370 } else {
21371 if (IS_CV == IS_UNUSED) {
21372 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21373 }
21374 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21375 }
21376 }
21377
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21378 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21379 {
21380 #if 0
21381 USE_OPLINE
21382 #endif
21383
21384 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21385 /* Behave like FETCH_OBJ_W */
21386 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21387 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21388 }
21389 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21390 } else {
21391 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21392 }
21393 }
21394
ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21395 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21396 {
21397 USE_OPLINE
21398 zend_string **rope;
21399 zval *var;
21400
21401 /* op1 and result are the same */
21402 rope = (zend_string**)EX_VAR(opline->op1.var);
21403 if (IS_CV == IS_CONST) {
21404 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21405 rope[opline->extended_value] = Z_STR_P(var);
21406 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21407 Z_ADDREF_P(var);
21408 }
21409 } else {
21410 var = EX_VAR(opline->op2.var);
21411 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21412 if (IS_CV == IS_CV) {
21413 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21414 } else {
21415 rope[opline->extended_value] = Z_STR_P(var);
21416 }
21417 } else {
21418 SAVE_OPLINE();
21419 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21420 ZVAL_UNDEFINED_OP2();
21421 }
21422 rope[opline->extended_value] = zval_get_string_func(var);
21423
21424 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21425 }
21426 }
21427 ZEND_VM_NEXT_OPCODE();
21428 }
21429
ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21430 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21431 {
21432 USE_OPLINE
21433 zend_string **rope;
21434 zval *var, *ret;
21435 uint32_t i;
21436
21437 rope = (zend_string**)EX_VAR(opline->op1.var);
21438 if (IS_CV == IS_CONST) {
21439 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21440 rope[opline->extended_value] = Z_STR_P(var);
21441 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21442 Z_ADDREF_P(var);
21443 }
21444 } else {
21445 var = EX_VAR(opline->op2.var);
21446 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21447 if (IS_CV == IS_CV) {
21448 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21449 } else {
21450 rope[opline->extended_value] = Z_STR_P(var);
21451 }
21452 } else {
21453 SAVE_OPLINE();
21454 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21455 ZVAL_UNDEFINED_OP2();
21456 }
21457 rope[opline->extended_value] = zval_get_string_func(var);
21458
21459 if (UNEXPECTED(EG(exception))) {
21460 for (i = 0; i <= opline->extended_value; i++) {
21461 zend_string_release_ex(rope[i], 0);
21462 }
21463 ZVAL_UNDEF(EX_VAR(opline->result.var));
21464 HANDLE_EXCEPTION();
21465 }
21466 }
21467 }
21468
21469 size_t len = 0;
21470 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
21471 for (i = 0; i <= opline->extended_value; i++) {
21472 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
21473 len += ZSTR_LEN(rope[i]);
21474 }
21475 ret = EX_VAR(opline->result.var);
21476 ZVAL_STR(ret, zend_string_alloc(len, 0));
21477 GC_ADD_FLAGS(Z_STR_P(ret), flags);
21478
21479 char *target = Z_STRVAL_P(ret);
21480 for (i = 0; i <= opline->extended_value; i++) {
21481 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
21482 target += ZSTR_LEN(rope[i]);
21483 zend_string_release_ex(rope[i], 0);
21484 }
21485 *target = '\0';
21486
21487 ZEND_VM_NEXT_OPCODE();
21488 }
21489
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21490 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21491 {
21492 USE_OPLINE
21493 zval *expr_ptr, new_expr;
21494
21495 SAVE_OPLINE();
21496 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21497 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21498 expr_ptr = zend_get_bad_ptr();
21499 if (Z_ISREF_P(expr_ptr)) {
21500 Z_ADDREF_P(expr_ptr);
21501 } else {
21502 ZVAL_MAKE_REF_EX(expr_ptr, 2);
21503 }
21504 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21505 } else {
21506 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21507 if (IS_TMP_VAR == IS_TMP_VAR) {
21508 /* pass */
21509 } else if (IS_TMP_VAR == IS_CONST) {
21510 Z_TRY_ADDREF_P(expr_ptr);
21511 } else if (IS_TMP_VAR == IS_CV) {
21512 ZVAL_DEREF(expr_ptr);
21513 Z_TRY_ADDREF_P(expr_ptr);
21514 } else /* if (IS_TMP_VAR == IS_VAR) */ {
21515 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21516 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21517
21518 expr_ptr = Z_REFVAL_P(expr_ptr);
21519 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21520 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21521 expr_ptr = &new_expr;
21522 efree_size(ref, sizeof(zend_reference));
21523 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21524 Z_ADDREF_P(expr_ptr);
21525 }
21526 }
21527 }
21528 }
21529
21530 if (IS_CV != IS_UNUSED) {
21531 zval *offset = EX_VAR(opline->op2.var);
21532 zend_string *str;
21533 zend_ulong hval;
21534
21535 add_again:
21536 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21537 str = Z_STR_P(offset);
21538 if (IS_CV != IS_CONST) {
21539 if (ZEND_HANDLE_NUMERIC(str, hval)) {
21540 goto num_index;
21541 }
21542 }
21543 str_index:
21544 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21545 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21546 hval = Z_LVAL_P(offset);
21547 num_index:
21548 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21549 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21550 offset = Z_REFVAL_P(offset);
21551 goto add_again;
21552 } else if (Z_TYPE_P(offset) == IS_NULL) {
21553 str = ZSTR_EMPTY_ALLOC();
21554 goto str_index;
21555 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21556 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21557 goto num_index;
21558 } else if (Z_TYPE_P(offset) == IS_FALSE) {
21559 hval = 0;
21560 goto num_index;
21561 } else if (Z_TYPE_P(offset) == IS_TRUE) {
21562 hval = 1;
21563 goto num_index;
21564 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21565 zend_use_resource_as_offset(offset);
21566 hval = Z_RES_HANDLE_P(offset);
21567 goto num_index;
21568 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21569 ZVAL_UNDEFINED_OP2();
21570 str = ZSTR_EMPTY_ALLOC();
21571 goto str_index;
21572 } else {
21573 zend_illegal_array_offset_access(offset);
21574 zval_ptr_dtor_nogc(expr_ptr);
21575 }
21576
21577 } else {
21578 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21579 zend_cannot_add_element();
21580 zval_ptr_dtor_nogc(expr_ptr);
21581 }
21582 }
21583 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21584 }
21585
ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21586 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21587 {
21588 zval *array;
21589 uint32_t size;
21590 USE_OPLINE
21591
21592 array = EX_VAR(opline->result.var);
21593 if (IS_TMP_VAR != IS_UNUSED) {
21594 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21595 ZVAL_ARR(array, zend_new_array(size));
21596 /* Explicitly initialize array as not-packed if flag is set */
21597 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21598 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21599 }
21600 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21601 } else {
21602 ZVAL_ARR(array, zend_new_array(0));
21603 ZEND_VM_NEXT_OPCODE();
21604 }
21605 }
21606
ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21607 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21608 {
21609 USE_OPLINE
21610
21611 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21612
21613 SAVE_OPLINE();
21614 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21615 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21616 }
21617
21618 /* Destroy the previously yielded value */
21619 zval_ptr_dtor(&generator->value);
21620
21621 /* Destroy the previously yielded key */
21622 zval_ptr_dtor(&generator->key);
21623
21624 /* Set the new yielded value */
21625 if (IS_TMP_VAR != IS_UNUSED) {
21626 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21627 /* Constants and temporary variables aren't yieldable by reference,
21628 * but we still allow them with a notice. */
21629 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21630 zval *value;
21631
21632 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21633
21634 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21635 ZVAL_COPY_VALUE(&generator->value, value);
21636 if (IS_TMP_VAR == IS_CONST) {
21637 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21638 Z_ADDREF(generator->value);
21639 }
21640 }
21641 } else {
21642 zval *value_ptr = zend_get_bad_ptr();
21643
21644 /* If a function call result is yielded and the function did
21645 * not return by reference we throw a notice. */
21646 do {
21647 if (IS_TMP_VAR == IS_VAR) {
21648 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21649 if (opline->extended_value == ZEND_RETURNS_FUNCTION
21650 && !Z_ISREF_P(value_ptr)) {
21651 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21652 ZVAL_COPY(&generator->value, value_ptr);
21653 break;
21654 }
21655 }
21656 if (Z_ISREF_P(value_ptr)) {
21657 Z_ADDREF_P(value_ptr);
21658 } else {
21659 ZVAL_MAKE_REF_EX(value_ptr, 2);
21660 }
21661 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21662 } while (0);
21663
21664 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21665 }
21666 } else {
21667 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21668
21669 /* Consts, temporary variables and references need copying */
21670 if (IS_TMP_VAR == IS_CONST) {
21671 ZVAL_COPY_VALUE(&generator->value, value);
21672 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21673 Z_ADDREF(generator->value);
21674 }
21675 } else if (IS_TMP_VAR == IS_TMP_VAR) {
21676 ZVAL_COPY_VALUE(&generator->value, value);
21677 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21678 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21679
21680 } else {
21681 ZVAL_COPY_VALUE(&generator->value, value);
21682 if (IS_TMP_VAR == IS_CV) {
21683 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21684 }
21685 }
21686 }
21687 } else {
21688 /* If no value was specified yield null */
21689 ZVAL_NULL(&generator->value);
21690 }
21691
21692 /* Set the new yielded key */
21693 if (IS_CV != IS_UNUSED) {
21694 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21695 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21696 key = Z_REFVAL_P(key);
21697 }
21698 ZVAL_COPY(&generator->key, key);
21699
21700 if (Z_TYPE(generator->key) == IS_LONG
21701 && Z_LVAL(generator->key) > generator->largest_used_integer_key
21702 ) {
21703 generator->largest_used_integer_key = Z_LVAL(generator->key);
21704 }
21705 } else {
21706 /* If no key was specified we use auto-increment keys */
21707 generator->largest_used_integer_key++;
21708 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21709 }
21710
21711 if (RETURN_VALUE_USED(opline)) {
21712 /* If the return value of yield is used set the send
21713 * target and initialize it to NULL */
21714 generator->send_target = EX_VAR(opline->result.var);
21715 ZVAL_NULL(generator->send_target);
21716 } else {
21717 generator->send_target = NULL;
21718 }
21719
21720 /* We increment to the next op, so we are at the correct position when the
21721 * generator is resumed. */
21722 ZEND_VM_INC_OPCODE();
21723
21724 /* The GOTO VM uses a local opline variable. We need to set the opline
21725 * variable in execute_data so we don't resume at an old position. */
21726 SAVE_OPLINE();
21727
21728 ZEND_VM_RETURN();
21729 }
21730
ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21731 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21732 {
21733 USE_OPLINE
21734 zval *closure, *var;
21735
21736 closure = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21737 if (opline->extended_value & ZEND_BIND_REF) {
21738 /* By-ref binding */
21739 var = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
21740 if (Z_ISREF_P(var)) {
21741 Z_ADDREF_P(var);
21742 } else {
21743 ZVAL_MAKE_REF_EX(var, 2);
21744 }
21745 } else {
21746 var = EX_VAR(opline->op2.var);
21747 if (UNEXPECTED(Z_ISUNDEF_P(var)) && !(opline->extended_value & ZEND_BIND_IMPLICIT)) {
21748 SAVE_OPLINE();
21749 var = ZVAL_UNDEFINED_OP2();
21750 if (UNEXPECTED(EG(exception))) {
21751 HANDLE_EXCEPTION();
21752 }
21753 }
21754 ZVAL_DEREF(var);
21755 Z_TRY_ADDREF_P(var);
21756 }
21757
21758 zend_closure_bind_var_ex(closure,
21759 (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT)), var);
21760 ZEND_VM_NEXT_OPCODE();
21761 }
21762
zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)21763 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
21764 {
21765 USE_OPLINE
21766 zval *var_ptr;
21767
21768 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21769
21770 SAVE_OPLINE();
21771 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
21772 ZVAL_UNDEFINED_OP1();
21773 ZVAL_NULL(var_ptr);
21774 }
21775
21776 do {
21777 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
21778 zend_reference *ref = Z_REF_P(var_ptr);
21779 var_ptr = Z_REFVAL_P(var_ptr);
21780 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
21781 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
21782 break;
21783 }
21784 }
21785 increment_function(var_ptr);
21786 } while (0);
21787
21788 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
21789 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
21790 }
21791
21792 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21793 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21794 }
21795
ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21796 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_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(0)) {
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_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21814 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(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 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
21822 fast_long_increment_function(var_ptr);
21823 if (UNEXPECTED(1)) {
21824 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
21825 }
21826 ZEND_VM_NEXT_OPCODE();
21827 }
21828
21829 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21830 }
21831
zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)21832 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
21833 {
21834 USE_OPLINE
21835 zval *var_ptr;
21836
21837 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21838
21839 SAVE_OPLINE();
21840 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
21841 ZVAL_UNDEFINED_OP1();
21842 ZVAL_NULL(var_ptr);
21843 }
21844
21845 do {
21846 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
21847 zend_reference *ref = Z_REF_P(var_ptr);
21848 var_ptr = Z_REFVAL_P(var_ptr);
21849
21850 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
21851 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
21852 break;
21853 }
21854 }
21855 decrement_function(var_ptr);
21856 } while (0);
21857
21858 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
21859 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
21860 }
21861
21862 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21863 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21864 }
21865
ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21866 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_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(0)) {
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_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21884 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(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 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
21892 fast_long_decrement_function(var_ptr);
21893 if (UNEXPECTED(1)) {
21894 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
21895 }
21896 ZEND_VM_NEXT_OPCODE();
21897 }
21898
21899 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21900 }
21901
zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)21902 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
21903 {
21904 USE_OPLINE
21905 zval *var_ptr;
21906
21907 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21908
21909 SAVE_OPLINE();
21910 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
21911 ZVAL_UNDEFINED_OP1();
21912 ZVAL_NULL(var_ptr);
21913 }
21914
21915 do {
21916 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
21917 zend_reference *ref = Z_REF_P(var_ptr);
21918 var_ptr = Z_REFVAL_P(var_ptr);
21919
21920 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
21921 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
21922 break;
21923 }
21924 }
21925 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
21926
21927 increment_function(var_ptr);
21928 } while (0);
21929
21930 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21931 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21932 }
21933
ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21934 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21935 {
21936 USE_OPLINE
21937 zval *var_ptr;
21938
21939 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21940
21941 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
21942 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
21943 fast_long_increment_function(var_ptr);
21944 ZEND_VM_NEXT_OPCODE();
21945 }
21946
21947 ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21948 }
21949
zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)21950 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
21951 {
21952 USE_OPLINE
21953 zval *var_ptr;
21954
21955 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21956
21957 SAVE_OPLINE();
21958 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
21959 ZVAL_UNDEFINED_OP1();
21960 ZVAL_NULL(var_ptr);
21961 }
21962
21963 do {
21964 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
21965 zend_reference *ref = Z_REF_P(var_ptr);
21966 var_ptr = Z_REFVAL_P(var_ptr);
21967
21968 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
21969 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
21970 break;
21971 }
21972 }
21973 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
21974
21975 decrement_function(var_ptr);
21976 } while (0);
21977
21978 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21979 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21980 }
21981
ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21982 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21983 {
21984 USE_OPLINE
21985 zval *var_ptr;
21986
21987 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21988
21989 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
21990 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
21991 fast_long_decrement_function(var_ptr);
21992 ZEND_VM_NEXT_OPCODE();
21993 }
21994
21995 ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21996 }
21997
ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21998 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21999 {
22000 USE_OPLINE
22001 zval *retval_ptr;
22002 zval *return_value;
22003
22004 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22005 return_value = EX(return_value);
22006
22007 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
22008 SAVE_OPLINE();
22009 retval_ptr = ZVAL_UNDEFINED_OP1();
22010 if (return_value) {
22011 ZVAL_NULL(return_value);
22012 }
22013 } else if (!return_value) {
22014 if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
22015 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
22016 SAVE_OPLINE();
22017 rc_dtor_func(Z_COUNTED_P(retval_ptr));
22018 }
22019 }
22020 } else {
22021 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22022 ZVAL_COPY_VALUE(return_value, retval_ptr);
22023 if (IS_VAR == IS_CONST) {
22024 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
22025 Z_ADDREF_P(return_value);
22026 }
22027 }
22028 } else if (IS_VAR == IS_CV) {
22029 do {
22030 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22031 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
22032 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
22033 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22034 ZVAL_COPY_VALUE(return_value, retval_ptr);
22035 if (GC_MAY_LEAK(ref)) {
22036 SAVE_OPLINE();
22037 gc_possible_root(ref);
22038 }
22039 ZVAL_NULL(retval_ptr);
22040 break;
22041 } else {
22042 Z_ADDREF_P(retval_ptr);
22043 }
22044 } else {
22045 retval_ptr = Z_REFVAL_P(retval_ptr);
22046 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22047 Z_ADDREF_P(retval_ptr);
22048 }
22049 }
22050 }
22051 ZVAL_COPY_VALUE(return_value, retval_ptr);
22052 } while (0);
22053 } else /* if (IS_VAR == IS_VAR) */ {
22054 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22055 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22056
22057 retval_ptr = Z_REFVAL_P(retval_ptr);
22058 ZVAL_COPY_VALUE(return_value, retval_ptr);
22059 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22060 efree_size(ref, sizeof(zend_reference));
22061 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22062 Z_ADDREF_P(retval_ptr);
22063 }
22064 } else {
22065 ZVAL_COPY_VALUE(return_value, retval_ptr);
22066 }
22067 }
22068 }
22069
22070
22071
22072 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22073 }
22074
ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22075 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22076 {
22077 USE_OPLINE
22078 zval *retval_ptr;
22079 zval *return_value;
22080
22081 SAVE_OPLINE();
22082
22083 return_value = EX(return_value);
22084
22085 do {
22086 if ((IS_VAR & (IS_CONST|IS_TMP_VAR)) ||
22087 (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
22088 /* Not supposed to happen, but we'll allow it */
22089 zend_error(E_NOTICE, "Only variable references should be returned by reference");
22090
22091 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22092 if (!return_value) {
22093 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22094 } else {
22095 if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22096 ZVAL_COPY_VALUE(return_value, retval_ptr);
22097 break;
22098 }
22099
22100 ZVAL_NEW_REF(return_value, retval_ptr);
22101 if (IS_VAR == IS_CONST) {
22102 Z_TRY_ADDREF_P(retval_ptr);
22103 }
22104 }
22105 break;
22106 }
22107
22108 retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22109
22110 if (IS_VAR == IS_VAR) {
22111 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
22112 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
22113 zend_error(E_NOTICE, "Only variable references should be returned by reference");
22114 if (return_value) {
22115 ZVAL_NEW_REF(return_value, retval_ptr);
22116 } else {
22117 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22118 }
22119 break;
22120 }
22121 }
22122
22123 if (return_value) {
22124 if (Z_ISREF_P(retval_ptr)) {
22125 Z_ADDREF_P(retval_ptr);
22126 } else {
22127 ZVAL_MAKE_REF_EX(retval_ptr, 2);
22128 }
22129 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
22130 }
22131
22132 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22133 } while (0);
22134
22135
22136 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22137 }
22138
ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22139 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22140 {
22141 USE_OPLINE
22142 zval *retval;
22143
22144 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
22145
22146 SAVE_OPLINE();
22147 retval = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22148
22149 /* Copy return value into generator->retval */
22150 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22151 ZVAL_COPY_VALUE(&generator->retval, retval);
22152 if (IS_VAR == IS_CONST) {
22153 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
22154 Z_ADDREF(generator->retval);
22155 }
22156 }
22157 } else if (IS_VAR == IS_CV) {
22158 ZVAL_COPY_DEREF(&generator->retval, retval);
22159 } else /* if (IS_VAR == IS_VAR) */ {
22160 if (UNEXPECTED(Z_ISREF_P(retval))) {
22161 zend_refcounted *ref = Z_COUNTED_P(retval);
22162
22163 retval = Z_REFVAL_P(retval);
22164 ZVAL_COPY_VALUE(&generator->retval, retval);
22165 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22166 efree_size(ref, sizeof(zend_reference));
22167 } else if (Z_OPT_REFCOUNTED_P(retval)) {
22168 Z_ADDREF_P(retval);
22169 }
22170 } else {
22171 ZVAL_COPY_VALUE(&generator->retval, retval);
22172 }
22173 }
22174
22175 EG(current_execute_data) = EX(prev_execute_data);
22176
22177 /* Close the generator to free up resources */
22178 zend_generator_close(generator, 1);
22179
22180 /* Pass execution back to handling code */
22181 ZEND_VM_RETURN();
22182 }
22183
ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22184 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22185 {
22186 USE_OPLINE
22187 zval *arg, *param;
22188
22189 SAVE_OPLINE();
22190
22191 arg = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22192 param = ZEND_CALL_VAR(EX(call), opline->result.var);
22193 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
22194 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
22195 Z_TRY_ADDREF_P(arg);
22196 ZVAL_NEW_REF(param, arg);
22197 } else {
22198 ZVAL_COPY(param, arg);
22199 }
22200
22201 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22202 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22203 }
22204
ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22205 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22206 {
22207 USE_OPLINE
22208 zval *expr;
22209 zval *result = EX_VAR(opline->result.var);
22210 HashTable *ht;
22211
22212 SAVE_OPLINE();
22213 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22214
22215 switch (opline->extended_value) {
22216 case IS_LONG:
22217 ZVAL_LONG(result, zval_get_long(expr));
22218 break;
22219 case IS_DOUBLE:
22220 ZVAL_DOUBLE(result, zval_get_double(expr));
22221 break;
22222 case IS_STRING:
22223 ZVAL_STR(result, zval_get_string(expr));
22224 break;
22225 default:
22226 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
22227 if (IS_VAR & (IS_VAR|IS_CV)) {
22228 ZVAL_DEREF(expr);
22229 }
22230 /* If value is already of correct type, return it directly */
22231 if (Z_TYPE_P(expr) == opline->extended_value) {
22232 ZVAL_COPY_VALUE(result, expr);
22233 if (IS_VAR == IS_CONST) {
22234 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
22235 } else if (IS_VAR != IS_TMP_VAR) {
22236 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
22237 }
22238
22239 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22240 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22241 }
22242
22243 if (opline->extended_value == IS_ARRAY) {
22244 if (IS_VAR == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
22245 if (Z_TYPE_P(expr) != IS_NULL) {
22246 ZVAL_ARR(result, zend_new_array(1));
22247 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
22248 if (IS_VAR == IS_CONST) {
22249 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
22250 } else {
22251 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
22252 }
22253 } else {
22254 ZVAL_EMPTY_ARRAY(result);
22255 }
22256 } else if (Z_OBJ_P(expr)->properties == NULL
22257 && Z_OBJ_HT_P(expr)->get_properties_for == NULL
22258 && Z_OBJ_HT_P(expr)->get_properties == zend_std_get_properties) {
22259 /* Optimized version without rebuilding properties HashTable */
22260 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
22261 } else {
22262 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
22263 if (obj_ht) {
22264 /* fast copy */
22265 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
22266 (Z_OBJCE_P(expr)->default_properties_count ||
22267 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
22268 GC_IS_RECURSIVE(obj_ht))));
22269 zend_release_properties(obj_ht);
22270 } else {
22271 ZVAL_EMPTY_ARRAY(result);
22272 }
22273 }
22274 } else {
22275 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
22276 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
22277 if (Z_TYPE_P(expr) == IS_ARRAY) {
22278 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
22279 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
22280 /* TODO: try not to duplicate immutable arrays as well ??? */
22281 ht = zend_array_dup(ht);
22282 }
22283 Z_OBJ_P(result)->properties = ht;
22284 } else if (Z_TYPE_P(expr) != IS_NULL) {
22285 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
22286 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
22287 if (IS_VAR == IS_CONST) {
22288 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
22289 } else {
22290 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
22291 }
22292 }
22293 }
22294 }
22295
22296 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22297 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22298 }
22299
ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22300 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22301 {
22302 USE_OPLINE
22303 zval *array_ptr, *result;
22304
22305 SAVE_OPLINE();
22306
22307 array_ptr = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22308 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
22309 result = EX_VAR(opline->result.var);
22310 ZVAL_COPY_VALUE(result, array_ptr);
22311 if (IS_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
22312 Z_ADDREF_P(array_ptr);
22313 }
22314 Z_FE_POS_P(result) = 0;
22315
22316 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22317 ZEND_VM_NEXT_OPCODE();
22318 } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
22319 zend_object *zobj = Z_OBJ_P(array_ptr);
22320 if (!zobj->ce->get_iterator) {
22321 HashTable *properties = zobj->properties;
22322 if (properties) {
22323 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
22324 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
22325 GC_DELREF(properties);
22326 }
22327 properties = zobj->properties = zend_array_dup(properties);
22328 }
22329 } else {
22330 properties = zobj->handlers->get_properties(zobj);
22331 }
22332
22333 result = EX_VAR(opline->result.var);
22334 ZVAL_COPY_VALUE(result, array_ptr);
22335 if (IS_VAR != IS_TMP_VAR) {
22336 Z_ADDREF_P(array_ptr);
22337 }
22338
22339 if (zend_hash_num_elements(properties) == 0) {
22340 Z_FE_ITER_P(result) = (uint32_t) -1;
22341 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22342 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22343 }
22344
22345 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
22346 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22347 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22348 } else {
22349 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
22350
22351 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22352 if (UNEXPECTED(EG(exception))) {
22353 HANDLE_EXCEPTION();
22354 } else if (is_empty) {
22355 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22356 } else {
22357 ZEND_VM_NEXT_OPCODE();
22358 }
22359 }
22360 } else {
22361 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
22362 ZVAL_UNDEF(EX_VAR(opline->result.var));
22363 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
22364 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22365 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22366 }
22367 }
22368
ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22369 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22370 {
22371 USE_OPLINE
22372 zval *array_ptr, *array_ref;
22373
22374 SAVE_OPLINE();
22375
22376 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22377 array_ref = array_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22378 if (Z_ISREF_P(array_ref)) {
22379 array_ptr = Z_REFVAL_P(array_ref);
22380 }
22381 } else {
22382 array_ref = array_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22383 }
22384
22385 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
22386 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22387 if (array_ptr == array_ref) {
22388 ZVAL_NEW_REF(array_ref, array_ref);
22389 array_ptr = Z_REFVAL_P(array_ref);
22390 }
22391 Z_ADDREF_P(array_ref);
22392 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
22393 } else {
22394 array_ref = EX_VAR(opline->result.var);
22395 ZVAL_NEW_REF(array_ref, array_ptr);
22396 array_ptr = Z_REFVAL_P(array_ref);
22397 }
22398 if (IS_VAR == IS_CONST) {
22399 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
22400 } else {
22401 SEPARATE_ARRAY(array_ptr);
22402 }
22403 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
22404
22405 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22406 ZEND_VM_NEXT_OPCODE();
22407 } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
22408 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
22409 HashTable *properties;
22410 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22411 if (array_ptr == array_ref) {
22412 ZVAL_NEW_REF(array_ref, array_ref);
22413 array_ptr = Z_REFVAL_P(array_ref);
22414 }
22415 Z_ADDREF_P(array_ref);
22416 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
22417 } else {
22418 array_ptr = EX_VAR(opline->result.var);
22419 ZVAL_COPY_VALUE(array_ptr, array_ref);
22420 }
22421 if (Z_OBJ_P(array_ptr)->properties
22422 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
22423 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
22424 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
22425 }
22426 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
22427 }
22428
22429 properties = Z_OBJPROP_P(array_ptr);
22430 if (zend_hash_num_elements(properties) == 0) {
22431 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
22432 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22433 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22434 }
22435
22436 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
22437 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22438 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22439 } else {
22440 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
22441 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22442 if (UNEXPECTED(EG(exception))) {
22443 HANDLE_EXCEPTION();
22444 } else if (is_empty) {
22445 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22446 } else {
22447 ZEND_VM_NEXT_OPCODE();
22448 }
22449 }
22450 } else {
22451 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
22452 ZVAL_UNDEF(EX_VAR(opline->result.var));
22453 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
22454 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22455 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22456 }
22457 }
22458
ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22459 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22460 {
22461 USE_OPLINE
22462 zval *array;
22463 zval *value;
22464 uint32_t value_type;
22465 HashTable *fe_ht;
22466 HashPosition pos;
22467
22468 array = EX_VAR(opline->op1.var);
22469 if (UNEXPECTED(Z_TYPE_P(array) != IS_ARRAY)) {
22470 ZEND_VM_TAIL_CALL(zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22471 }
22472 fe_ht = Z_ARRVAL_P(array);
22473 pos = Z_FE_POS_P(array);
22474 if (HT_IS_PACKED(fe_ht)) {
22475 value = fe_ht->arPacked + pos;
22476 while (1) {
22477 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22478 /* reached end of iteration */
22479 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
22480 ZEND_VM_CONTINUE();
22481 }
22482 value_type = Z_TYPE_INFO_P(value);
22483 ZEND_ASSERT(value_type != IS_INDIRECT);
22484 if (EXPECTED(value_type != IS_UNDEF)) {
22485 break;
22486 }
22487 pos++;
22488 value++;
22489 }
22490 Z_FE_POS_P(array) = pos + 1;
22491 if (RETURN_VALUE_USED(opline)) {
22492 ZVAL_LONG(EX_VAR(opline->result.var), pos);
22493 }
22494 } else {
22495 Bucket *p;
22496
22497 p = fe_ht->arData + pos;
22498 while (1) {
22499 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22500 /* reached end of iteration */
22501 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
22502 ZEND_VM_CONTINUE();
22503 }
22504 pos++;
22505 value = &p->val;
22506 value_type = Z_TYPE_INFO_P(value);
22507 ZEND_ASSERT(value_type != IS_INDIRECT);
22508 if (EXPECTED(value_type != IS_UNDEF)) {
22509 break;
22510 }
22511 p++;
22512 }
22513 Z_FE_POS_P(array) = pos;
22514 if (RETURN_VALUE_USED(opline)) {
22515 if (!p->key) {
22516 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
22517 } else {
22518 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
22519 }
22520 }
22521 }
22522 if (EXPECTED(opline->op2_type == IS_CV)) {
22523 zval *variable_ptr = EX_VAR(opline->op2.var);
22524 SAVE_OPLINE();
22525 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
22526 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22527 } else {
22528 zval *res = EX_VAR(opline->op2.var);
22529 zend_refcounted *gc = Z_COUNTED_P(value);
22530
22531 ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
22532 if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
22533 GC_ADDREF(gc);
22534 }
22535 ZEND_VM_NEXT_OPCODE();
22536 }
22537 }
22538
ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22539 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22540 {
22541 USE_OPLINE
22542 zval *array;
22543 zval *value;
22544 uint32_t value_type;
22545 HashTable *fe_ht;
22546 HashPosition pos;
22547 Bucket *p;
22548
22549 array = EX_VAR(opline->op1.var);
22550 SAVE_OPLINE();
22551
22552 ZVAL_DEREF(array);
22553 if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
22554 pos = zend_hash_iterator_pos_ex(Z_FE_ITER_P(EX_VAR(opline->op1.var)), array);
22555 fe_ht = Z_ARRVAL_P(array);
22556 if (HT_IS_PACKED(fe_ht)) {
22557 value = fe_ht->arPacked + pos;
22558 while (1) {
22559 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22560 /* reached end of iteration */
22561 goto fe_fetch_w_exit;
22562 }
22563 value_type = Z_TYPE_INFO_P(value);
22564 ZEND_ASSERT(value_type != IS_INDIRECT);
22565 if (EXPECTED(value_type != IS_UNDEF)) {
22566 break;
22567 }
22568 pos++;
22569 value++;
22570 }
22571 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1;
22572 if (RETURN_VALUE_USED(opline)) {
22573 ZVAL_LONG(EX_VAR(opline->result.var), pos);
22574 }
22575 } else {
22576 p = fe_ht->arData + pos;
22577 while (1) {
22578 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22579 /* reached end of iteration */
22580 goto fe_fetch_w_exit;
22581 }
22582 pos++;
22583 value = &p->val;
22584 value_type = Z_TYPE_INFO_P(value);
22585 ZEND_ASSERT(value_type != IS_INDIRECT);
22586 if (EXPECTED(value_type != IS_UNDEF)) {
22587 break;
22588 }
22589 p++;
22590 }
22591 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
22592 if (RETURN_VALUE_USED(opline)) {
22593 if (!p->key) {
22594 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
22595 } else {
22596 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
22597 }
22598 }
22599 }
22600 } else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
22601 zend_object_iterator *iter;
22602
22603 if ((iter = zend_iterator_unwrap(array)) == NULL) {
22604 /* plain object */
22605
22606 fe_ht = Z_OBJPROP_P(array);
22607 pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
22608 p = fe_ht->arData + pos;
22609 while (1) {
22610 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22611 /* reached end of iteration */
22612 goto fe_fetch_w_exit;
22613 }
22614 pos++;
22615 value = &p->val;
22616 value_type = Z_TYPE_INFO_P(value);
22617 if (EXPECTED(value_type != IS_UNDEF)) {
22618 if (UNEXPECTED(value_type == IS_INDIRECT)) {
22619 value = Z_INDIRECT_P(value);
22620 value_type = Z_TYPE_INFO_P(value);
22621 if (EXPECTED(value_type != IS_UNDEF)
22622 && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
22623 if ((value_type & Z_TYPE_MASK) != IS_REFERENCE) {
22624 zend_property_info *prop_info =
22625 zend_get_property_info_for_slot(Z_OBJ_P(array), value);
22626 if (prop_info) {
22627 if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) {
22628 zend_throw_error(NULL,
22629 "Cannot acquire reference to readonly property %s::$%s",
22630 ZSTR_VAL(prop_info->ce->name), ZSTR_VAL(p->key));
22631 UNDEF_RESULT();
22632 HANDLE_EXCEPTION();
22633 }
22634 if (ZEND_TYPE_IS_SET(prop_info->type)) {
22635 ZVAL_NEW_REF(value, value);
22636 ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(value), prop_info);
22637 value_type = IS_REFERENCE_EX;
22638 }
22639 }
22640 }
22641 break;
22642 }
22643 } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
22644 || !p->key
22645 || zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
22646 break;
22647 }
22648 }
22649 p++;
22650 }
22651 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
22652 if (RETURN_VALUE_USED(opline)) {
22653 if (UNEXPECTED(!p->key)) {
22654 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
22655 } else if (ZSTR_VAL(p->key)[0]) {
22656 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
22657 } else {
22658 const char *class_name, *prop_name;
22659 size_t prop_name_len;
22660 zend_unmangle_property_name_ex(
22661 p->key, &class_name, &prop_name, &prop_name_len);
22662 ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
22663 }
22664 }
22665 } else {
22666 const zend_object_iterator_funcs *funcs = iter->funcs;
22667 if (++iter->index > 0) {
22668 /* This could cause an endless loop if index becomes zero again.
22669 * In case that ever happens we need an additional flag. */
22670 funcs->move_forward(iter);
22671 if (UNEXPECTED(EG(exception) != NULL)) {
22672 UNDEF_RESULT();
22673 HANDLE_EXCEPTION();
22674 }
22675 if (UNEXPECTED(funcs->valid(iter) == FAILURE)) {
22676 /* reached end of iteration */
22677 if (UNEXPECTED(EG(exception) != NULL)) {
22678 UNDEF_RESULT();
22679 HANDLE_EXCEPTION();
22680 }
22681 goto fe_fetch_w_exit;
22682 }
22683 }
22684 value = funcs->get_current_data(iter);
22685 if (UNEXPECTED(EG(exception) != NULL)) {
22686 UNDEF_RESULT();
22687 HANDLE_EXCEPTION();
22688 }
22689 if (!value) {
22690 /* failure in get_current_data */
22691 goto fe_fetch_w_exit;
22692 }
22693 if (RETURN_VALUE_USED(opline)) {
22694 if (funcs->get_current_key) {
22695 funcs->get_current_key(iter, EX_VAR(opline->result.var));
22696 if (UNEXPECTED(EG(exception) != NULL)) {
22697 UNDEF_RESULT();
22698 HANDLE_EXCEPTION();
22699 }
22700 } else {
22701 ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
22702 }
22703 }
22704 value_type = Z_TYPE_INFO_P(value);
22705 }
22706 } else {
22707 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array));
22708 if (UNEXPECTED(EG(exception))) {
22709 UNDEF_RESULT();
22710 HANDLE_EXCEPTION();
22711 }
22712 fe_fetch_w_exit:
22713 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
22714 ZEND_VM_CONTINUE();
22715 }
22716
22717 if (EXPECTED((value_type & Z_TYPE_MASK) != IS_REFERENCE)) {
22718 zend_refcounted *gc = Z_COUNTED_P(value);
22719 zval *ref;
22720 ZVAL_NEW_EMPTY_REF(value);
22721 ref = Z_REFVAL_P(value);
22722 ZVAL_COPY_VALUE_EX(ref, value, gc, value_type);
22723 }
22724 if (EXPECTED(opline->op2_type == IS_CV)) {
22725 zval *variable_ptr = EX_VAR(opline->op2.var);
22726 if (EXPECTED(variable_ptr != value)) {
22727 zend_reference *ref;
22728
22729 ref = Z_REF_P(value);
22730 GC_ADDREF(ref);
22731 i_zval_ptr_dtor(variable_ptr);
22732 ZVAL_REF(variable_ptr, ref);
22733 }
22734 } else {
22735 Z_ADDREF_P(value);
22736 ZVAL_REF(EX_VAR(opline->op2.var), Z_REF_P(value));
22737 }
22738 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22739 }
22740
ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22741 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22742 {
22743 USE_OPLINE
22744 zval *value;
22745 zend_reference *ref = NULL;
22746 bool ret;
22747
22748 SAVE_OPLINE();
22749 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22750
22751 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) {
22752 if (IS_VAR == IS_VAR) {
22753 ref = Z_REF_P(value);
22754 }
22755 value = Z_REFVAL_P(value);
22756 }
22757
22758 ret = i_zend_is_true(value);
22759
22760 if (UNEXPECTED(EG(exception))) {
22761 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22762 ZVAL_UNDEF(EX_VAR(opline->result.var));
22763 HANDLE_EXCEPTION();
22764 }
22765
22766 if (ret) {
22767 zval *result = EX_VAR(opline->result.var);
22768
22769 ZVAL_COPY_VALUE(result, value);
22770 if (IS_VAR == IS_CONST) {
22771 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
22772 } else if (IS_VAR == IS_CV) {
22773 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
22774 } else if (IS_VAR == IS_VAR && ref) {
22775 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22776 efree_size(ref, sizeof(zend_reference));
22777 } else if (Z_OPT_REFCOUNTED_P(result)) {
22778 Z_ADDREF_P(result);
22779 }
22780 }
22781 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22782 }
22783
22784 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22785 ZEND_VM_NEXT_OPCODE();
22786 }
22787
ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22788 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22789 {
22790 USE_OPLINE
22791 zval *value;
22792 zend_reference *ref = NULL;
22793
22794 SAVE_OPLINE();
22795 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22796
22797 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
22798 if (IS_VAR & IS_VAR) {
22799 ref = Z_REF_P(value);
22800 }
22801 value = Z_REFVAL_P(value);
22802 }
22803
22804 if (Z_TYPE_P(value) > IS_NULL) {
22805 zval *result = EX_VAR(opline->result.var);
22806 ZVAL_COPY_VALUE(result, value);
22807 if (IS_VAR == IS_CONST) {
22808 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
22809 } else if (IS_VAR == IS_CV) {
22810 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
22811 } else if ((IS_VAR & IS_VAR) && ref) {
22812 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22813 efree_size(ref, sizeof(zend_reference));
22814 } else if (Z_OPT_REFCOUNTED_P(result)) {
22815 Z_ADDREF_P(result);
22816 }
22817 }
22818 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22819 }
22820
22821 if ((IS_VAR & IS_VAR) && ref) {
22822 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22823 efree_size(ref, sizeof(zend_reference));
22824 }
22825 }
22826 ZEND_VM_NEXT_OPCODE();
22827 }
22828
ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22829 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22830 {
22831 USE_OPLINE
22832 zval *val, *result;
22833
22834 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22835
22836 if (Z_TYPE_P(val) > IS_NULL) {
22837 do {
22838 if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
22839 val = Z_REFVAL_P(val);
22840 if (Z_TYPE_P(val) <= IS_NULL) {
22841 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22842 break;
22843 }
22844 }
22845 ZEND_VM_NEXT_OPCODE();
22846 } while (0);
22847 }
22848
22849 result = EX_VAR(opline->result.var);
22850 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
22851 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
22852 ZVAL_NULL(result);
22853 if (IS_VAR == IS_CV
22854 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
22855 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
22856 ) {
22857 SAVE_OPLINE();
22858 ZVAL_UNDEFINED_OP1();
22859 if (UNEXPECTED(EG(exception) != NULL)) {
22860 HANDLE_EXCEPTION();
22861 }
22862 }
22863 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
22864 ZVAL_FALSE(result);
22865 } else {
22866 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
22867 ZVAL_TRUE(result);
22868 }
22869
22870 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22871 }
22872
ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22873 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22874 {
22875 USE_OPLINE
22876 zval *value;
22877 zval *result = EX_VAR(opline->result.var);
22878
22879 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22880 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
22881 SAVE_OPLINE();
22882 ZVAL_UNDEFINED_OP1();
22883 ZVAL_NULL(result);
22884 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22885 }
22886
22887 if (IS_VAR == IS_CV) {
22888 ZVAL_COPY_DEREF(result, value);
22889 } else if (IS_VAR == IS_VAR) {
22890 if (UNEXPECTED(Z_ISREF_P(value))) {
22891 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
22892 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
22893 efree_size(Z_REF_P(value), sizeof(zend_reference));
22894 } else if (Z_OPT_REFCOUNTED_P(result)) {
22895 Z_ADDREF_P(result);
22896 }
22897 } else {
22898 ZVAL_COPY_VALUE(result, value);
22899 }
22900 } else {
22901 ZVAL_COPY_VALUE(result, value);
22902 if (IS_VAR == IS_CONST) {
22903 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
22904 Z_ADDREF_P(result);
22905 }
22906 }
22907 }
22908 ZEND_VM_NEXT_OPCODE();
22909 }
22910
ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22911 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22912 {
22913 USE_OPLINE
22914 zval *varptr, *arg;
22915
22916 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22917 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
22918
22919 if (IS_VAR == IS_CV) {
22920 ZVAL_COPY(arg, varptr);
22921 } else /* if (IS_VAR == IS_VAR) */ {
22922 ZVAL_COPY_VALUE(arg, varptr);
22923 }
22924
22925 ZEND_VM_NEXT_OPCODE();
22926 }
22927
ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22928 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22929 {
22930 USE_OPLINE
22931 zval *op1, *op2;
22932 bool result;
22933
22934 SAVE_OPLINE();
22935 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22936 op2 = RT_CONSTANT(opline, opline->op2);
22937 result = fast_is_identical_function(op1, op2);
22938 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22939
22940 ZEND_VM_SMART_BRANCH(result, 1);
22941 }
22942
ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22943 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22944 {
22945 USE_OPLINE
22946 zval *op1, *op2;
22947 bool result;
22948
22949 SAVE_OPLINE();
22950 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22951 op2 = RT_CONSTANT(opline, opline->op2);
22952 result = fast_is_identical_function(op1, op2);
22953
22954 ZEND_VM_SMART_BRANCH(result, 1);
22955 }
22956
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22957 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22958 {
22959 USE_OPLINE
22960 zval *op1, *op2;
22961 bool result;
22962
22963 SAVE_OPLINE();
22964 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22965 op2 = RT_CONSTANT(opline, opline->op2);
22966 result = fast_is_not_identical_function(op1, op2);
22967 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22968
22969 ZEND_VM_SMART_BRANCH(result, 1);
22970 }
22971
ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22972 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22973 {
22974 USE_OPLINE
22975 zval *object;
22976 zval *property;
22977 zval *value;
22978 zval *zptr;
22979 void **cache_slot;
22980 zend_property_info *prop_info;
22981 zend_object *zobj;
22982 zend_string *name, *tmp_name;
22983
22984 SAVE_OPLINE();
22985 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22986 property = RT_CONSTANT(opline, opline->op2);
22987
22988 do {
22989 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
22990
22991 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
22992 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
22993 object = Z_REFVAL_P(object);
22994 goto assign_op_object;
22995 }
22996 if (IS_VAR == IS_CV
22997 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
22998 ZVAL_UNDEFINED_OP1();
22999 }
23000 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23001 break;
23002 }
23003
23004 assign_op_object:
23005 /* here we are sure we are dealing with an object */
23006 zobj = Z_OBJ_P(object);
23007 if (IS_CONST == IS_CONST) {
23008 name = Z_STR_P(property);
23009 } else {
23010 name = zval_try_get_tmp_string(property, &tmp_name);
23011 if (UNEXPECTED(!name)) {
23012 UNDEF_RESULT();
23013 break;
23014 }
23015 }
23016 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
23017 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23018 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23019 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23020 ZVAL_NULL(EX_VAR(opline->result.var));
23021 }
23022 } else {
23023 zval *orig_zptr = zptr;
23024 zend_reference *ref;
23025
23026 do {
23027 if (UNEXPECTED(Z_ISREF_P(zptr))) {
23028 ref = Z_REF_P(zptr);
23029 zptr = Z_REFVAL_P(zptr);
23030 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23031 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23032 break;
23033 }
23034 }
23035
23036 if (IS_CONST == IS_CONST) {
23037 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23038 } else {
23039 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
23040 }
23041 if (prop_info) {
23042 /* special case for typed properties */
23043 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
23044 } else {
23045 zend_binary_op(zptr, zptr, value OPLINE_CC);
23046 }
23047 } while (0);
23048
23049 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23050 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
23051 }
23052 }
23053 } else {
23054 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
23055 }
23056 if (IS_CONST != IS_CONST) {
23057 zend_tmp_string_release(tmp_name);
23058 }
23059 } while (0);
23060
23061 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23062
23063 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23064 /* assign_obj has two opcodes! */
23065 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23066 }
23067
23068 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23069 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23070 {
23071 USE_OPLINE
23072 zval *var_ptr;
23073 zval *value, *container, *dim;
23074 HashTable *ht;
23075
23076 SAVE_OPLINE();
23077 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23078
23079 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23080 assign_dim_op_array:
23081 SEPARATE_ARRAY(container);
23082 ht = Z_ARRVAL_P(container);
23083 assign_dim_op_new_array:
23084 dim = RT_CONSTANT(opline, opline->op2);
23085 if (IS_CONST == IS_UNUSED) {
23086 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
23087 if (UNEXPECTED(!var_ptr)) {
23088 zend_cannot_add_element();
23089 goto assign_dim_op_ret_null;
23090 }
23091 } else {
23092 if (IS_CONST == IS_CONST) {
23093 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
23094 } else {
23095 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
23096 }
23097 if (UNEXPECTED(!var_ptr)) {
23098 goto assign_dim_op_ret_null;
23099 }
23100 }
23101
23102 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
23103
23104 do {
23105 if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
23106 zend_reference *ref = Z_REF_P(var_ptr);
23107 var_ptr = Z_REFVAL_P(var_ptr);
23108 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23109 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23110 break;
23111 }
23112 }
23113 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23114 } while (0);
23115
23116 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23117 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23118 }
23119 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23120 } else {
23121 if (EXPECTED(Z_ISREF_P(container))) {
23122 container = Z_REFVAL_P(container);
23123 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23124 goto assign_dim_op_array;
23125 }
23126 }
23127
23128 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
23129 zend_object *obj = Z_OBJ_P(container);
23130
23131 dim = RT_CONSTANT(opline, opline->op2);
23132 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
23133 dim++;
23134 }
23135 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
23136 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
23137 uint8_t old_type;
23138
23139 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
23140 ZVAL_UNDEFINED_OP1();
23141 }
23142 ht = zend_new_array(8);
23143 old_type = Z_TYPE_P(container);
23144 ZVAL_ARR(container, ht);
23145 if (UNEXPECTED(old_type == IS_FALSE)) {
23146 GC_ADDREF(ht);
23147 zend_false_to_array_deprecated();
23148 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
23149 zend_array_destroy(ht);
23150 goto assign_dim_op_ret_null;
23151 }
23152 }
23153 goto assign_dim_op_new_array;
23154 } else {
23155 dim = RT_CONSTANT(opline, opline->op2);
23156 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
23157 assign_dim_op_ret_null:
23158 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23159 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23160 ZVAL_NULL(EX_VAR(opline->result.var));
23161 }
23162 }
23163 }
23164
23165 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23166 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23167 }
23168
ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23169 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23170 {
23171 USE_OPLINE
23172 zval *var_ptr;
23173 zval *value;
23174
23175 SAVE_OPLINE();
23176 value = RT_CONSTANT(opline, opline->op2);
23177 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23178
23179 do {
23180 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
23181 zend_reference *ref = Z_REF_P(var_ptr);
23182 var_ptr = Z_REFVAL_P(var_ptr);
23183 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23184 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23185 break;
23186 }
23187 }
23188 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23189 } while (0);
23190
23191 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23192 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23193 }
23194
23195 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23196 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23197 }
23198
ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23199 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23200 {
23201 USE_OPLINE
23202 zval *object;
23203 zval *property;
23204 zval *zptr;
23205 void **cache_slot;
23206 zend_property_info *prop_info;
23207 zend_object *zobj;
23208 zend_string *name, *tmp_name;
23209
23210 SAVE_OPLINE();
23211 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23212 property = RT_CONSTANT(opline, opline->op2);
23213
23214 do {
23215 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23216 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23217 object = Z_REFVAL_P(object);
23218 goto pre_incdec_object;
23219 }
23220 if (IS_VAR == IS_CV
23221 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23222 ZVAL_UNDEFINED_OP1();
23223 }
23224 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23225 break;
23226 }
23227
23228 pre_incdec_object:
23229 /* here we are sure we are dealing with an object */
23230 zobj = Z_OBJ_P(object);
23231 if (IS_CONST == IS_CONST) {
23232 name = Z_STR_P(property);
23233 } else {
23234 name = zval_try_get_tmp_string(property, &tmp_name);
23235 if (UNEXPECTED(!name)) {
23236 UNDEF_RESULT();
23237 break;
23238 }
23239 }
23240 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
23241 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23242 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23243 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23244 ZVAL_NULL(EX_VAR(opline->result.var));
23245 }
23246 } else {
23247 if (IS_CONST == IS_CONST) {
23248 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
23249 } else {
23250 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
23251 }
23252 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23253 }
23254 } else {
23255 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23256 }
23257 if (IS_CONST != IS_CONST) {
23258 zend_tmp_string_release(tmp_name);
23259 }
23260 } while (0);
23261
23262 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23263 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23264 }
23265
ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23266 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23267 {
23268 USE_OPLINE
23269 zval *object;
23270 zval *property;
23271 zval *zptr;
23272 void **cache_slot;
23273 zend_property_info *prop_info;
23274 zend_object *zobj;
23275 zend_string *name, *tmp_name;
23276
23277 SAVE_OPLINE();
23278 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23279 property = RT_CONSTANT(opline, opline->op2);
23280
23281 do {
23282 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23283 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23284 object = Z_REFVAL_P(object);
23285 goto post_incdec_object;
23286 }
23287 if (IS_VAR == IS_CV
23288 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23289 ZVAL_UNDEFINED_OP1();
23290 }
23291 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23292 break;
23293 }
23294
23295 post_incdec_object:
23296 /* here we are sure we are dealing with an object */
23297 zobj = Z_OBJ_P(object);
23298 if (IS_CONST == IS_CONST) {
23299 name = Z_STR_P(property);
23300 } else {
23301 name = zval_try_get_tmp_string(property, &tmp_name);
23302 if (UNEXPECTED(!name)) {
23303 ZVAL_UNDEF(EX_VAR(opline->result.var));
23304 break;
23305 }
23306 }
23307 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
23308 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23309 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23310 ZVAL_NULL(EX_VAR(opline->result.var));
23311 } else {
23312 if (IS_CONST == IS_CONST) {
23313 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23314 } else {
23315 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
23316 }
23317
23318 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23319 }
23320 } else {
23321 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23322 }
23323 if (IS_CONST != IS_CONST) {
23324 zend_tmp_string_release(tmp_name);
23325 }
23326 } while (0);
23327
23328 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23329 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23330 }
23331
ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23332 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23333 {
23334 USE_OPLINE
23335 zval *container;
23336
23337 SAVE_OPLINE();
23338 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23339 zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23340
23341 if (IS_VAR == IS_VAR) {
23342 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23343 }
23344 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23345 }
23346
ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23347 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23348 {
23349 USE_OPLINE
23350 zval *container;
23351
23352 SAVE_OPLINE();
23353 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23354 zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23355
23356 if (IS_VAR == IS_VAR) {
23357 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23358 }
23359 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23360 }
23361
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23362 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23363 {
23364 #if 0
23365 USE_OPLINE
23366 #endif
23367
23368 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
23369 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
23370 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23371 }
23372 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23373 } else {
23374 if (IS_CONST == IS_UNUSED) {
23375 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23376 }
23377 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23378 }
23379 }
23380
ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23381 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23382 {
23383 USE_OPLINE
23384 zval *container;
23385
23386 SAVE_OPLINE();
23387 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23388 zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23389
23390 if (IS_VAR == IS_VAR) {
23391 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23392 }
23393 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23394 }
23395
ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23396 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23397 {
23398 USE_OPLINE
23399 zval *property, *container, *result;
23400
23401 SAVE_OPLINE();
23402
23403 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23404 property = RT_CONSTANT(opline, opline->op2);
23405 result = EX_VAR(opline->result.var);
23406 zend_fetch_property_address(
23407 result, container, IS_VAR, property, IS_CONST,
23408 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
23409 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
23410
23411 if (IS_VAR == IS_VAR) {
23412 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23413 }
23414 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23415 }
23416
ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23417 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23418 {
23419 USE_OPLINE
23420 zval *property, *container, *result;
23421
23422 SAVE_OPLINE();
23423 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23424 property = RT_CONSTANT(opline, opline->op2);
23425 result = EX_VAR(opline->result.var);
23426 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);
23427
23428 if (IS_VAR == IS_VAR) {
23429 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23430 }
23431 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23432 }
23433
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23434 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23435 {
23436 #if 0
23437 USE_OPLINE
23438 #endif
23439
23440 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
23441 /* Behave like FETCH_OBJ_W */
23442 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
23443 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23444 }
23445 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23446 } else {
23447 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23448 }
23449 }
23450
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23451 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23452 {
23453 USE_OPLINE
23454 zval *container, *property, *result;
23455
23456 SAVE_OPLINE();
23457 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23458 property = RT_CONSTANT(opline, opline->op2);
23459 result = EX_VAR(opline->result.var);
23460 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);
23461
23462 if (IS_VAR == IS_VAR) {
23463 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23464 }
23465 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23466 }
23467
ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23468 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23469 {
23470 USE_OPLINE
23471 zval *container, *dim;
23472
23473 SAVE_OPLINE();
23474 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23475 dim = RT_CONSTANT(opline, opline->op2);
23476
23477 if (IS_VAR == IS_VAR
23478 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
23479 && UNEXPECTED(!Z_ISREF_P(container))
23480 ) {
23481 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
23482 zend_fetch_dimension_address_LIST_r(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23483 } else {
23484 zend_fetch_dimension_address_W(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23485 }
23486
23487 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23488 }
23489
ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23490 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23491 {
23492 USE_OPLINE
23493 zval *object, *value, tmp;
23494 zend_object *zobj;
23495 zend_string *name, *tmp_name;
23496 zend_refcounted *garbage = NULL;
23497
23498 SAVE_OPLINE();
23499 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23500 value = RT_CONSTANT((opline+1), (opline+1)->op1);
23501
23502 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23503 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23504 object = Z_REFVAL_P(object);
23505 goto assign_object;
23506 }
23507 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
23508 value = &EG(uninitialized_zval);
23509 goto free_and_exit_assign_obj;
23510 }
23511
23512 assign_object:
23513 zobj = Z_OBJ_P(object);
23514 if (IS_CONST == IS_CONST) {
23515 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
23516 void **cache_slot = CACHE_ADDR(opline->extended_value);
23517 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
23518 zval *property_val;
23519
23520 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
23521 property_val = OBJ_PROP(zobj, prop_offset);
23522 if (Z_TYPE_P(property_val) != IS_UNDEF) {
23523 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
23524
23525 if (prop_info != NULL) {
23526 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
23527 goto free_and_exit_assign_obj;
23528 } else {
23529 fast_assign_obj:
23530 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
23531 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23532 ZVAL_COPY(EX_VAR(opline->result.var), value);
23533 }
23534 goto exit_assign_obj;
23535 }
23536 }
23537 } else {
23538 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23539 if (EXPECTED(zobj->properties != NULL)) {
23540 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
23541 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
23542 GC_DELREF(zobj->properties);
23543 }
23544 zobj->properties = zend_array_dup(zobj->properties);
23545 }
23546 property_val = zend_hash_find_known_hash(zobj->properties, name);
23547 if (property_val) {
23548 goto fast_assign_obj;
23549 }
23550 }
23551
23552 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
23553 if (EXPECTED(zobj->properties == NULL)) {
23554 rebuild_object_properties(zobj);
23555 }
23556 if (IS_CONST == IS_CONST) {
23557 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
23558 Z_ADDREF_P(value);
23559 }
23560 } else if (IS_CONST != IS_TMP_VAR) {
23561 if (Z_ISREF_P(value)) {
23562 if (IS_CONST == IS_VAR) {
23563 zend_reference *ref = Z_REF_P(value);
23564 if (GC_DELREF(ref) == 0) {
23565 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
23566 efree_size(ref, sizeof(zend_reference));
23567 value = &tmp;
23568 } else {
23569 value = Z_REFVAL_P(value);
23570 Z_TRY_ADDREF_P(value);
23571 }
23572 } else {
23573 value = Z_REFVAL_P(value);
23574 Z_TRY_ADDREF_P(value);
23575 }
23576 } else if (IS_CONST == IS_CV) {
23577 Z_TRY_ADDREF_P(value);
23578 }
23579 }
23580 zend_hash_add_new(zobj->properties, name, value);
23581 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23582 ZVAL_COPY(EX_VAR(opline->result.var), value);
23583 }
23584 goto exit_assign_obj;
23585 }
23586 }
23587 }
23588 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23589 } else {
23590 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
23591 if (UNEXPECTED(!name)) {
23592
23593 UNDEF_RESULT();
23594 goto exit_assign_obj;
23595 }
23596 }
23597
23598 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
23599 ZVAL_DEREF(value);
23600 }
23601
23602 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
23603
23604 if (IS_CONST != IS_CONST) {
23605 zend_tmp_string_release(tmp_name);
23606 }
23607
23608 free_and_exit_assign_obj:
23609 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
23610 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
23611 }
23612
23613 exit_assign_obj:
23614 if (garbage) {
23615 GC_DTOR_NO_REF(garbage);
23616 }
23617
23618 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23619 /* assign_obj has two opcodes! */
23620 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23621 }
23622
23623 /* 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)23624 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23625 {
23626 USE_OPLINE
23627 zval *object, *value, tmp;
23628 zend_object *zobj;
23629 zend_string *name, *tmp_name;
23630 zend_refcounted *garbage = NULL;
23631
23632 SAVE_OPLINE();
23633 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23634 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
23635
23636 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23637 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23638 object = Z_REFVAL_P(object);
23639 goto assign_object;
23640 }
23641 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
23642 value = &EG(uninitialized_zval);
23643 goto free_and_exit_assign_obj;
23644 }
23645
23646 assign_object:
23647 zobj = Z_OBJ_P(object);
23648 if (IS_CONST == IS_CONST) {
23649 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
23650 void **cache_slot = CACHE_ADDR(opline->extended_value);
23651 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
23652 zval *property_val;
23653
23654 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
23655 property_val = OBJ_PROP(zobj, prop_offset);
23656 if (Z_TYPE_P(property_val) != IS_UNDEF) {
23657 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
23658
23659 if (prop_info != NULL) {
23660 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
23661 goto free_and_exit_assign_obj;
23662 } else {
23663 fast_assign_obj:
23664 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
23665 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23666 ZVAL_COPY(EX_VAR(opline->result.var), value);
23667 }
23668 goto exit_assign_obj;
23669 }
23670 }
23671 } else {
23672 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23673 if (EXPECTED(zobj->properties != NULL)) {
23674 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
23675 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
23676 GC_DELREF(zobj->properties);
23677 }
23678 zobj->properties = zend_array_dup(zobj->properties);
23679 }
23680 property_val = zend_hash_find_known_hash(zobj->properties, name);
23681 if (property_val) {
23682 goto fast_assign_obj;
23683 }
23684 }
23685
23686 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
23687 if (EXPECTED(zobj->properties == NULL)) {
23688 rebuild_object_properties(zobj);
23689 }
23690 if (IS_TMP_VAR == IS_CONST) {
23691 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
23692 Z_ADDREF_P(value);
23693 }
23694 } else if (IS_TMP_VAR != IS_TMP_VAR) {
23695 if (Z_ISREF_P(value)) {
23696 if (IS_TMP_VAR == IS_VAR) {
23697 zend_reference *ref = Z_REF_P(value);
23698 if (GC_DELREF(ref) == 0) {
23699 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
23700 efree_size(ref, sizeof(zend_reference));
23701 value = &tmp;
23702 } else {
23703 value = Z_REFVAL_P(value);
23704 Z_TRY_ADDREF_P(value);
23705 }
23706 } else {
23707 value = Z_REFVAL_P(value);
23708 Z_TRY_ADDREF_P(value);
23709 }
23710 } else if (IS_TMP_VAR == IS_CV) {
23711 Z_TRY_ADDREF_P(value);
23712 }
23713 }
23714 zend_hash_add_new(zobj->properties, name, value);
23715 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23716 ZVAL_COPY(EX_VAR(opline->result.var), value);
23717 }
23718 goto exit_assign_obj;
23719 }
23720 }
23721 }
23722 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23723 } else {
23724 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
23725 if (UNEXPECTED(!name)) {
23726 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
23727 UNDEF_RESULT();
23728 goto exit_assign_obj;
23729 }
23730 }
23731
23732 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
23733 ZVAL_DEREF(value);
23734 }
23735
23736 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
23737
23738 if (IS_CONST != IS_CONST) {
23739 zend_tmp_string_release(tmp_name);
23740 }
23741
23742 free_and_exit_assign_obj:
23743 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
23744 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
23745 }
23746 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
23747 exit_assign_obj:
23748 if (garbage) {
23749 GC_DTOR_NO_REF(garbage);
23750 }
23751
23752 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23753 /* assign_obj has two opcodes! */
23754 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23755 }
23756
23757 /* 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)23758 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23759 {
23760 USE_OPLINE
23761 zval *object, *value, tmp;
23762 zend_object *zobj;
23763 zend_string *name, *tmp_name;
23764 zend_refcounted *garbage = NULL;
23765
23766 SAVE_OPLINE();
23767 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23768 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
23769
23770 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23771 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23772 object = Z_REFVAL_P(object);
23773 goto assign_object;
23774 }
23775 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
23776 value = &EG(uninitialized_zval);
23777 goto free_and_exit_assign_obj;
23778 }
23779
23780 assign_object:
23781 zobj = Z_OBJ_P(object);
23782 if (IS_CONST == IS_CONST) {
23783 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
23784 void **cache_slot = CACHE_ADDR(opline->extended_value);
23785 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
23786 zval *property_val;
23787
23788 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
23789 property_val = OBJ_PROP(zobj, prop_offset);
23790 if (Z_TYPE_P(property_val) != IS_UNDEF) {
23791 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
23792
23793 if (prop_info != NULL) {
23794 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
23795 goto free_and_exit_assign_obj;
23796 } else {
23797 fast_assign_obj:
23798 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
23799 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23800 ZVAL_COPY(EX_VAR(opline->result.var), value);
23801 }
23802 goto exit_assign_obj;
23803 }
23804 }
23805 } else {
23806 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23807 if (EXPECTED(zobj->properties != NULL)) {
23808 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
23809 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
23810 GC_DELREF(zobj->properties);
23811 }
23812 zobj->properties = zend_array_dup(zobj->properties);
23813 }
23814 property_val = zend_hash_find_known_hash(zobj->properties, name);
23815 if (property_val) {
23816 goto fast_assign_obj;
23817 }
23818 }
23819
23820 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
23821 if (EXPECTED(zobj->properties == NULL)) {
23822 rebuild_object_properties(zobj);
23823 }
23824 if (IS_VAR == IS_CONST) {
23825 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
23826 Z_ADDREF_P(value);
23827 }
23828 } else if (IS_VAR != IS_TMP_VAR) {
23829 if (Z_ISREF_P(value)) {
23830 if (IS_VAR == IS_VAR) {
23831 zend_reference *ref = Z_REF_P(value);
23832 if (GC_DELREF(ref) == 0) {
23833 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
23834 efree_size(ref, sizeof(zend_reference));
23835 value = &tmp;
23836 } else {
23837 value = Z_REFVAL_P(value);
23838 Z_TRY_ADDREF_P(value);
23839 }
23840 } else {
23841 value = Z_REFVAL_P(value);
23842 Z_TRY_ADDREF_P(value);
23843 }
23844 } else if (IS_VAR == IS_CV) {
23845 Z_TRY_ADDREF_P(value);
23846 }
23847 }
23848 zend_hash_add_new(zobj->properties, name, value);
23849 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23850 ZVAL_COPY(EX_VAR(opline->result.var), value);
23851 }
23852 goto exit_assign_obj;
23853 }
23854 }
23855 }
23856 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23857 } else {
23858 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
23859 if (UNEXPECTED(!name)) {
23860 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
23861 UNDEF_RESULT();
23862 goto exit_assign_obj;
23863 }
23864 }
23865
23866 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
23867 ZVAL_DEREF(value);
23868 }
23869
23870 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
23871
23872 if (IS_CONST != IS_CONST) {
23873 zend_tmp_string_release(tmp_name);
23874 }
23875
23876 free_and_exit_assign_obj:
23877 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
23878 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
23879 }
23880 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
23881 exit_assign_obj:
23882 if (garbage) {
23883 GC_DTOR_NO_REF(garbage);
23884 }
23885
23886 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23887 /* assign_obj has two opcodes! */
23888 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23889 }
23890
23891 /* 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)23892 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23893 {
23894 USE_OPLINE
23895 zval *object, *value, tmp;
23896 zend_object *zobj;
23897 zend_string *name, *tmp_name;
23898 zend_refcounted *garbage = NULL;
23899
23900 SAVE_OPLINE();
23901 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23902 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
23903
23904 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23905 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23906 object = Z_REFVAL_P(object);
23907 goto assign_object;
23908 }
23909 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
23910 value = &EG(uninitialized_zval);
23911 goto free_and_exit_assign_obj;
23912 }
23913
23914 assign_object:
23915 zobj = Z_OBJ_P(object);
23916 if (IS_CONST == IS_CONST) {
23917 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
23918 void **cache_slot = CACHE_ADDR(opline->extended_value);
23919 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
23920 zval *property_val;
23921
23922 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
23923 property_val = OBJ_PROP(zobj, prop_offset);
23924 if (Z_TYPE_P(property_val) != IS_UNDEF) {
23925 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
23926
23927 if (prop_info != NULL) {
23928 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
23929 goto free_and_exit_assign_obj;
23930 } else {
23931 fast_assign_obj:
23932 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
23933 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23934 ZVAL_COPY(EX_VAR(opline->result.var), value);
23935 }
23936 goto exit_assign_obj;
23937 }
23938 }
23939 } else {
23940 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23941 if (EXPECTED(zobj->properties != NULL)) {
23942 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
23943 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
23944 GC_DELREF(zobj->properties);
23945 }
23946 zobj->properties = zend_array_dup(zobj->properties);
23947 }
23948 property_val = zend_hash_find_known_hash(zobj->properties, name);
23949 if (property_val) {
23950 goto fast_assign_obj;
23951 }
23952 }
23953
23954 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
23955 if (EXPECTED(zobj->properties == NULL)) {
23956 rebuild_object_properties(zobj);
23957 }
23958 if (IS_CV == IS_CONST) {
23959 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
23960 Z_ADDREF_P(value);
23961 }
23962 } else if (IS_CV != IS_TMP_VAR) {
23963 if (Z_ISREF_P(value)) {
23964 if (IS_CV == IS_VAR) {
23965 zend_reference *ref = Z_REF_P(value);
23966 if (GC_DELREF(ref) == 0) {
23967 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
23968 efree_size(ref, sizeof(zend_reference));
23969 value = &tmp;
23970 } else {
23971 value = Z_REFVAL_P(value);
23972 Z_TRY_ADDREF_P(value);
23973 }
23974 } else {
23975 value = Z_REFVAL_P(value);
23976 Z_TRY_ADDREF_P(value);
23977 }
23978 } else if (IS_CV == IS_CV) {
23979 Z_TRY_ADDREF_P(value);
23980 }
23981 }
23982 zend_hash_add_new(zobj->properties, name, value);
23983 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23984 ZVAL_COPY(EX_VAR(opline->result.var), value);
23985 }
23986 goto exit_assign_obj;
23987 }
23988 }
23989 }
23990 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23991 } else {
23992 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
23993 if (UNEXPECTED(!name)) {
23994
23995 UNDEF_RESULT();
23996 goto exit_assign_obj;
23997 }
23998 }
23999
24000 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24001 ZVAL_DEREF(value);
24002 }
24003
24004 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24005
24006 if (IS_CONST != IS_CONST) {
24007 zend_tmp_string_release(tmp_name);
24008 }
24009
24010 free_and_exit_assign_obj:
24011 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24012 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24013 }
24014
24015 exit_assign_obj:
24016 if (garbage) {
24017 GC_DTOR_NO_REF(garbage);
24018 }
24019
24020 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24021 /* assign_obj has two opcodes! */
24022 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24023 }
24024
24025 /* 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)24026 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24027 {
24028 USE_OPLINE
24029 zval *object_ptr, *orig_object_ptr;
24030 zval *value;
24031 zval *variable_ptr;
24032 zval *dim;
24033 zend_refcounted *garbage = NULL;
24034
24035 SAVE_OPLINE();
24036 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24037
24038 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24039 try_assign_dim_array:
24040 SEPARATE_ARRAY(object_ptr);
24041 if (IS_CONST == IS_UNUSED) {
24042 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24043 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24044 HashTable *ht = Z_ARRVAL_P(object_ptr);
24045 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24046 GC_ADDREF(ht);
24047 }
24048 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24049 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24050 zend_array_destroy(ht);
24051 goto assign_dim_error;
24052 }
24053 }
24054 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24055 ZVAL_DEREF(value);
24056 }
24057 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24058 if (UNEXPECTED(value == NULL)) {
24059 zend_cannot_add_element();
24060 goto assign_dim_error;
24061 } else if (IS_CONST == IS_CV) {
24062 if (Z_REFCOUNTED_P(value)) {
24063 Z_ADDREF_P(value);
24064 }
24065 } else if (IS_CONST == IS_VAR) {
24066 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24067 if (Z_ISREF_P(free_op_data)) {
24068 if (Z_REFCOUNTED_P(value)) {
24069 Z_ADDREF_P(value);
24070 }
24071 zval_ptr_dtor_nogc(free_op_data);
24072 }
24073 } else if (IS_CONST == IS_CONST) {
24074 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24075 Z_ADDREF_P(value);
24076 }
24077 }
24078 } else {
24079 dim = RT_CONSTANT(opline, opline->op2);
24080 if (IS_CONST == IS_CONST) {
24081 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24082 } else {
24083 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24084 }
24085 if (UNEXPECTED(variable_ptr == NULL)) {
24086 goto assign_dim_error;
24087 }
24088 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24089 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24090 }
24091 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24092 ZVAL_COPY(EX_VAR(opline->result.var), value);
24093 }
24094 if (garbage) {
24095 GC_DTOR_NO_REF(garbage);
24096 }
24097 } else {
24098 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24099 object_ptr = Z_REFVAL_P(object_ptr);
24100 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24101 goto try_assign_dim_array;
24102 }
24103 }
24104 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24105 zend_object *obj = Z_OBJ_P(object_ptr);
24106
24107 GC_ADDREF(obj);
24108 dim = RT_CONSTANT(opline, opline->op2);
24109 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24110 dim = ZVAL_UNDEFINED_OP2();
24111 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24112 dim++;
24113 }
24114
24115 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24116 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24117 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24118 } else if (IS_CONST & (IS_CV|IS_VAR)) {
24119 ZVAL_DEREF(value);
24120 }
24121
24122 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24123
24124 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24125 zend_objects_store_del(obj);
24126 }
24127 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24128 if (IS_CONST == IS_UNUSED) {
24129 zend_use_new_element_for_string();
24130
24131 UNDEF_RESULT();
24132 } else {
24133 dim = RT_CONSTANT(opline, opline->op2);
24134 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24135 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24136
24137 }
24138 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24139 if (Z_ISREF_P(orig_object_ptr)
24140 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24141 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24142 dim = RT_CONSTANT(opline, opline->op2);
24143
24144 UNDEF_RESULT();
24145 } else {
24146 HashTable *ht = zend_new_array(8);
24147 uint8_t old_type = Z_TYPE_P(object_ptr);
24148
24149 ZVAL_ARR(object_ptr, ht);
24150 if (UNEXPECTED(old_type == IS_FALSE)) {
24151 GC_ADDREF(ht);
24152 zend_false_to_array_deprecated();
24153 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24154 zend_array_destroy(ht);
24155 goto assign_dim_error;
24156 }
24157 }
24158 goto try_assign_dim_array;
24159 }
24160 } else {
24161 zend_use_scalar_as_array();
24162 dim = RT_CONSTANT(opline, opline->op2);
24163 assign_dim_error:
24164
24165 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24166 ZVAL_NULL(EX_VAR(opline->result.var));
24167 }
24168 }
24169 }
24170 if (IS_CONST != IS_UNUSED) {
24171
24172 }
24173 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24174 /* assign_dim has two opcodes! */
24175 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24176 }
24177
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24178 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24179 {
24180 USE_OPLINE
24181 zval *object_ptr, *orig_object_ptr;
24182 zval *value;
24183 zval *variable_ptr;
24184 zval *dim;
24185 zend_refcounted *garbage = NULL;
24186
24187 SAVE_OPLINE();
24188 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24189
24190 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24191 try_assign_dim_array:
24192 SEPARATE_ARRAY(object_ptr);
24193 if (IS_CONST == IS_UNUSED) {
24194 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24195 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24196 HashTable *ht = Z_ARRVAL_P(object_ptr);
24197 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24198 GC_ADDREF(ht);
24199 }
24200 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24201 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24202 zend_array_destroy(ht);
24203 goto assign_dim_error;
24204 }
24205 }
24206 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
24207 ZVAL_DEREF(value);
24208 }
24209 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24210 if (UNEXPECTED(value == NULL)) {
24211 zend_cannot_add_element();
24212 goto assign_dim_error;
24213 } else if (IS_TMP_VAR == IS_CV) {
24214 if (Z_REFCOUNTED_P(value)) {
24215 Z_ADDREF_P(value);
24216 }
24217 } else if (IS_TMP_VAR == IS_VAR) {
24218 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24219 if (Z_ISREF_P(free_op_data)) {
24220 if (Z_REFCOUNTED_P(value)) {
24221 Z_ADDREF_P(value);
24222 }
24223 zval_ptr_dtor_nogc(free_op_data);
24224 }
24225 } else if (IS_TMP_VAR == IS_CONST) {
24226 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24227 Z_ADDREF_P(value);
24228 }
24229 }
24230 } else {
24231 dim = RT_CONSTANT(opline, opline->op2);
24232 if (IS_CONST == IS_CONST) {
24233 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24234 } else {
24235 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24236 }
24237 if (UNEXPECTED(variable_ptr == NULL)) {
24238 goto assign_dim_error;
24239 }
24240 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24241 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
24242 }
24243 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24244 ZVAL_COPY(EX_VAR(opline->result.var), value);
24245 }
24246 if (garbage) {
24247 GC_DTOR_NO_REF(garbage);
24248 }
24249 } else {
24250 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24251 object_ptr = Z_REFVAL_P(object_ptr);
24252 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24253 goto try_assign_dim_array;
24254 }
24255 }
24256 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24257 zend_object *obj = Z_OBJ_P(object_ptr);
24258
24259 GC_ADDREF(obj);
24260 dim = RT_CONSTANT(opline, opline->op2);
24261 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24262 dim = ZVAL_UNDEFINED_OP2();
24263 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24264 dim++;
24265 }
24266
24267 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24268 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24269 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24270 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
24271 ZVAL_DEREF(value);
24272 }
24273
24274 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24275
24276 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24277 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24278 zend_objects_store_del(obj);
24279 }
24280 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24281 if (IS_CONST == IS_UNUSED) {
24282 zend_use_new_element_for_string();
24283 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24284 UNDEF_RESULT();
24285 } else {
24286 dim = RT_CONSTANT(opline, opline->op2);
24287 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24288 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24289 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24290 }
24291 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24292 if (Z_ISREF_P(orig_object_ptr)
24293 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24294 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24295 dim = RT_CONSTANT(opline, opline->op2);
24296 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24297 UNDEF_RESULT();
24298 } else {
24299 HashTable *ht = zend_new_array(8);
24300 uint8_t old_type = Z_TYPE_P(object_ptr);
24301
24302 ZVAL_ARR(object_ptr, ht);
24303 if (UNEXPECTED(old_type == IS_FALSE)) {
24304 GC_ADDREF(ht);
24305 zend_false_to_array_deprecated();
24306 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24307 zend_array_destroy(ht);
24308 goto assign_dim_error;
24309 }
24310 }
24311 goto try_assign_dim_array;
24312 }
24313 } else {
24314 zend_use_scalar_as_array();
24315 dim = RT_CONSTANT(opline, opline->op2);
24316 assign_dim_error:
24317 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24318 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24319 ZVAL_NULL(EX_VAR(opline->result.var));
24320 }
24321 }
24322 }
24323 if (IS_CONST != IS_UNUSED) {
24324
24325 }
24326 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24327 /* assign_dim has two opcodes! */
24328 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24329 }
24330
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24331 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24332 {
24333 USE_OPLINE
24334 zval *object_ptr, *orig_object_ptr;
24335 zval *value;
24336 zval *variable_ptr;
24337 zval *dim;
24338 zend_refcounted *garbage = NULL;
24339
24340 SAVE_OPLINE();
24341 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24342
24343 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24344 try_assign_dim_array:
24345 SEPARATE_ARRAY(object_ptr);
24346 if (IS_CONST == IS_UNUSED) {
24347 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24348 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24349 HashTable *ht = Z_ARRVAL_P(object_ptr);
24350 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24351 GC_ADDREF(ht);
24352 }
24353 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24354 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24355 zend_array_destroy(ht);
24356 goto assign_dim_error;
24357 }
24358 }
24359 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
24360 ZVAL_DEREF(value);
24361 }
24362 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24363 if (UNEXPECTED(value == NULL)) {
24364 zend_cannot_add_element();
24365 goto assign_dim_error;
24366 } else if (IS_VAR == IS_CV) {
24367 if (Z_REFCOUNTED_P(value)) {
24368 Z_ADDREF_P(value);
24369 }
24370 } else if (IS_VAR == IS_VAR) {
24371 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24372 if (Z_ISREF_P(free_op_data)) {
24373 if (Z_REFCOUNTED_P(value)) {
24374 Z_ADDREF_P(value);
24375 }
24376 zval_ptr_dtor_nogc(free_op_data);
24377 }
24378 } else if (IS_VAR == IS_CONST) {
24379 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24380 Z_ADDREF_P(value);
24381 }
24382 }
24383 } else {
24384 dim = RT_CONSTANT(opline, opline->op2);
24385 if (IS_CONST == IS_CONST) {
24386 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24387 } else {
24388 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24389 }
24390 if (UNEXPECTED(variable_ptr == NULL)) {
24391 goto assign_dim_error;
24392 }
24393 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24394 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
24395 }
24396 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24397 ZVAL_COPY(EX_VAR(opline->result.var), value);
24398 }
24399 if (garbage) {
24400 GC_DTOR_NO_REF(garbage);
24401 }
24402 } else {
24403 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24404 object_ptr = Z_REFVAL_P(object_ptr);
24405 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24406 goto try_assign_dim_array;
24407 }
24408 }
24409 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24410 zend_object *obj = Z_OBJ_P(object_ptr);
24411
24412 GC_ADDREF(obj);
24413 dim = RT_CONSTANT(opline, opline->op2);
24414 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24415 dim = ZVAL_UNDEFINED_OP2();
24416 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24417 dim++;
24418 }
24419
24420 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24421 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24422 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24423 } else if (IS_VAR & (IS_CV|IS_VAR)) {
24424 ZVAL_DEREF(value);
24425 }
24426
24427 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24428
24429 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24430 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24431 zend_objects_store_del(obj);
24432 }
24433 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24434 if (IS_CONST == IS_UNUSED) {
24435 zend_use_new_element_for_string();
24436 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24437 UNDEF_RESULT();
24438 } else {
24439 dim = RT_CONSTANT(opline, opline->op2);
24440 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24441 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24442 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24443 }
24444 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24445 if (Z_ISREF_P(orig_object_ptr)
24446 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24447 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24448 dim = RT_CONSTANT(opline, opline->op2);
24449 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24450 UNDEF_RESULT();
24451 } else {
24452 HashTable *ht = zend_new_array(8);
24453 uint8_t old_type = Z_TYPE_P(object_ptr);
24454
24455 ZVAL_ARR(object_ptr, ht);
24456 if (UNEXPECTED(old_type == IS_FALSE)) {
24457 GC_ADDREF(ht);
24458 zend_false_to_array_deprecated();
24459 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24460 zend_array_destroy(ht);
24461 goto assign_dim_error;
24462 }
24463 }
24464 goto try_assign_dim_array;
24465 }
24466 } else {
24467 zend_use_scalar_as_array();
24468 dim = RT_CONSTANT(opline, opline->op2);
24469 assign_dim_error:
24470 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24471 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24472 ZVAL_NULL(EX_VAR(opline->result.var));
24473 }
24474 }
24475 }
24476 if (IS_CONST != IS_UNUSED) {
24477
24478 }
24479 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24480 /* assign_dim has two opcodes! */
24481 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24482 }
24483
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24484 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24485 {
24486 USE_OPLINE
24487 zval *object_ptr, *orig_object_ptr;
24488 zval *value;
24489 zval *variable_ptr;
24490 zval *dim;
24491 zend_refcounted *garbage = NULL;
24492
24493 SAVE_OPLINE();
24494 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24495
24496 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24497 try_assign_dim_array:
24498 SEPARATE_ARRAY(object_ptr);
24499 if (IS_CONST == IS_UNUSED) {
24500 value = EX_VAR((opline+1)->op1.var);
24501 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24502 HashTable *ht = Z_ARRVAL_P(object_ptr);
24503 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24504 GC_ADDREF(ht);
24505 }
24506 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24507 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24508 zend_array_destroy(ht);
24509 goto assign_dim_error;
24510 }
24511 }
24512 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24513 ZVAL_DEREF(value);
24514 }
24515 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24516 if (UNEXPECTED(value == NULL)) {
24517 zend_cannot_add_element();
24518 goto assign_dim_error;
24519 } else if (IS_CV == IS_CV) {
24520 if (Z_REFCOUNTED_P(value)) {
24521 Z_ADDREF_P(value);
24522 }
24523 } else if (IS_CV == IS_VAR) {
24524 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24525 if (Z_ISREF_P(free_op_data)) {
24526 if (Z_REFCOUNTED_P(value)) {
24527 Z_ADDREF_P(value);
24528 }
24529 zval_ptr_dtor_nogc(free_op_data);
24530 }
24531 } else if (IS_CV == IS_CONST) {
24532 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24533 Z_ADDREF_P(value);
24534 }
24535 }
24536 } else {
24537 dim = RT_CONSTANT(opline, opline->op2);
24538 if (IS_CONST == IS_CONST) {
24539 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24540 } else {
24541 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24542 }
24543 if (UNEXPECTED(variable_ptr == NULL)) {
24544 goto assign_dim_error;
24545 }
24546 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
24547 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
24548 }
24549 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24550 ZVAL_COPY(EX_VAR(opline->result.var), value);
24551 }
24552 if (garbage) {
24553 GC_DTOR_NO_REF(garbage);
24554 }
24555 } else {
24556 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24557 object_ptr = Z_REFVAL_P(object_ptr);
24558 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24559 goto try_assign_dim_array;
24560 }
24561 }
24562 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24563 zend_object *obj = Z_OBJ_P(object_ptr);
24564
24565 GC_ADDREF(obj);
24566 dim = RT_CONSTANT(opline, opline->op2);
24567 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24568 dim = ZVAL_UNDEFINED_OP2();
24569 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24570 dim++;
24571 }
24572
24573 value = EX_VAR((opline+1)->op1.var);
24574 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24575 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24576 } else if (IS_CV & (IS_CV|IS_VAR)) {
24577 ZVAL_DEREF(value);
24578 }
24579
24580 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24581
24582 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24583 zend_objects_store_del(obj);
24584 }
24585 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24586 if (IS_CONST == IS_UNUSED) {
24587 zend_use_new_element_for_string();
24588
24589 UNDEF_RESULT();
24590 } else {
24591 dim = RT_CONSTANT(opline, opline->op2);
24592 value = EX_VAR((opline+1)->op1.var);
24593 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24594
24595 }
24596 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24597 if (Z_ISREF_P(orig_object_ptr)
24598 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24599 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24600 dim = RT_CONSTANT(opline, opline->op2);
24601
24602 UNDEF_RESULT();
24603 } else {
24604 HashTable *ht = zend_new_array(8);
24605 uint8_t old_type = Z_TYPE_P(object_ptr);
24606
24607 ZVAL_ARR(object_ptr, ht);
24608 if (UNEXPECTED(old_type == IS_FALSE)) {
24609 GC_ADDREF(ht);
24610 zend_false_to_array_deprecated();
24611 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24612 zend_array_destroy(ht);
24613 goto assign_dim_error;
24614 }
24615 }
24616 goto try_assign_dim_array;
24617 }
24618 } else {
24619 zend_use_scalar_as_array();
24620 dim = RT_CONSTANT(opline, opline->op2);
24621 assign_dim_error:
24622
24623 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24624 ZVAL_NULL(EX_VAR(opline->result.var));
24625 }
24626 }
24627 }
24628 if (IS_CONST != IS_UNUSED) {
24629
24630 }
24631 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24632 /* assign_dim has two opcodes! */
24633 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24634 }
24635
ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24636 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24637 {
24638 USE_OPLINE
24639 zval *value;
24640 zval *variable_ptr;
24641
24642 SAVE_OPLINE();
24643 value = RT_CONSTANT(opline, opline->op2);
24644 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24645
24646 if (0 || UNEXPECTED(0)) {
24647 zend_refcounted *garbage = NULL;
24648
24649 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24650 if (UNEXPECTED(0)) {
24651 ZVAL_COPY(EX_VAR(opline->result.var), value);
24652 }
24653 if (garbage) {
24654 GC_DTOR_NO_REF(garbage);
24655 }
24656 } else {
24657 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
24658 }
24659 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24660 /* zend_assign_to_variable() always takes care of op2, never free it! */
24661
24662 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24663 }
24664
ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24665 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24666 {
24667 USE_OPLINE
24668 zval *value;
24669 zval *variable_ptr;
24670
24671 SAVE_OPLINE();
24672 value = RT_CONSTANT(opline, opline->op2);
24673 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24674
24675 if (0 || UNEXPECTED(1)) {
24676 zend_refcounted *garbage = NULL;
24677
24678 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24679 if (UNEXPECTED(1)) {
24680 ZVAL_COPY(EX_VAR(opline->result.var), value);
24681 }
24682 if (garbage) {
24683 GC_DTOR_NO_REF(garbage);
24684 }
24685 } else {
24686 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
24687 }
24688 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24689 /* zend_assign_to_variable() always takes care of op2, never free it! */
24690
24691 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24692 }
24693
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24694 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24695 {
24696 USE_OPLINE
24697 zval *property, *container, *value_ptr;
24698
24699 SAVE_OPLINE();
24700
24701 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24702 property = RT_CONSTANT(opline, opline->op2);
24703
24704 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24705
24706 if (1) {
24707 if (IS_VAR == IS_UNUSED) {
24708 if (IS_CONST == IS_CONST) {
24709 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24710 } else {
24711 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24712 }
24713 } else {
24714 if (IS_CONST == IS_CONST) {
24715 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24716 } else {
24717 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24718 }
24719 }
24720 } else {
24721 zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24722 }
24723
24724 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24725
24726 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24727 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24728 }
24729
24730 /* 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)24731 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24732 {
24733 USE_OPLINE
24734 zval *property, *container, *value_ptr;
24735
24736 SAVE_OPLINE();
24737
24738 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24739 property = RT_CONSTANT(opline, opline->op2);
24740
24741 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
24742
24743 if (1) {
24744 if (IS_VAR == IS_UNUSED) {
24745 if (IS_CONST == IS_CONST) {
24746 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24747 } else {
24748 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24749 }
24750 } else {
24751 if (IS_CONST == IS_CONST) {
24752 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24753 } else {
24754 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24755 }
24756 }
24757 } else {
24758 zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24759 }
24760
24761 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24762
24763
24764 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24765 }
24766
24767 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24768 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24769 {
24770 USE_OPLINE
24771 zval *function_name;
24772 zend_class_entry *ce;
24773 uint32_t call_info;
24774 zend_function *fbc;
24775 zend_execute_data *call;
24776
24777 SAVE_OPLINE();
24778
24779 if (IS_VAR == IS_CONST) {
24780 /* no function found. try a static method in class */
24781 ce = CACHED_PTR(opline->result.num);
24782 if (UNEXPECTED(ce == NULL)) {
24783 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);
24784 if (UNEXPECTED(ce == NULL)) {
24785
24786 HANDLE_EXCEPTION();
24787 }
24788 if (IS_CONST != IS_CONST) {
24789 CACHE_PTR(opline->result.num, ce);
24790 }
24791 }
24792 } else if (IS_VAR == IS_UNUSED) {
24793 ce = zend_fetch_class(NULL, opline->op1.num);
24794 if (UNEXPECTED(ce == NULL)) {
24795
24796 HANDLE_EXCEPTION();
24797 }
24798 } else {
24799 ce = Z_CE_P(EX_VAR(opline->op1.var));
24800 }
24801
24802 if (IS_VAR == IS_CONST &&
24803 IS_CONST == IS_CONST &&
24804 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
24805 /* nothing to do */
24806 } else if (IS_VAR != IS_CONST &&
24807 IS_CONST == IS_CONST &&
24808 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
24809 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
24810 } else if (IS_CONST != IS_UNUSED) {
24811 function_name = RT_CONSTANT(opline, opline->op2);
24812 if (IS_CONST != IS_CONST) {
24813 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
24814 do {
24815 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
24816 function_name = Z_REFVAL_P(function_name);
24817 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
24818 break;
24819 }
24820 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
24821 ZVAL_UNDEFINED_OP2();
24822 if (UNEXPECTED(EG(exception) != NULL)) {
24823 HANDLE_EXCEPTION();
24824 }
24825 }
24826 zend_throw_error(NULL, "Method name must be a string");
24827
24828 HANDLE_EXCEPTION();
24829 } while (0);
24830 }
24831 }
24832
24833 if (ce->get_static_method) {
24834 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
24835 } else {
24836 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
24837 }
24838 if (UNEXPECTED(fbc == NULL)) {
24839 if (EXPECTED(!EG(exception))) {
24840 zend_undefined_method(ce, Z_STR_P(function_name));
24841 }
24842
24843 HANDLE_EXCEPTION();
24844 }
24845 if (IS_CONST == IS_CONST &&
24846 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
24847 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
24848 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
24849 }
24850 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
24851 init_func_run_time_cache(&fbc->op_array);
24852 }
24853 if (IS_CONST != IS_CONST) {
24854
24855 }
24856 } else {
24857 if (UNEXPECTED(ce->constructor == NULL)) {
24858 zend_throw_error(NULL, "Cannot call constructor");
24859 HANDLE_EXCEPTION();
24860 }
24861 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
24862 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
24863 HANDLE_EXCEPTION();
24864 }
24865 fbc = ce->constructor;
24866 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
24867 init_func_run_time_cache(&fbc->op_array);
24868 }
24869 }
24870
24871 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
24872 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
24873 ce = (zend_class_entry*)Z_OBJ(EX(This));
24874 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
24875 } else {
24876 zend_non_static_method_call(fbc);
24877 HANDLE_EXCEPTION();
24878 }
24879 } else {
24880 /* previous opcode is ZEND_FETCH_CLASS */
24881 if (IS_VAR == IS_UNUSED
24882 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
24883 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
24884 if (Z_TYPE(EX(This)) == IS_OBJECT) {
24885 ce = Z_OBJCE(EX(This));
24886 } else {
24887 ce = Z_CE(EX(This));
24888 }
24889 }
24890 call_info = ZEND_CALL_NESTED_FUNCTION;
24891 }
24892
24893 call = zend_vm_stack_push_call_frame(call_info,
24894 fbc, opline->extended_value, ce);
24895 call->prev_execute_data = EX(call);
24896 EX(call) = call;
24897
24898 ZEND_VM_NEXT_OPCODE();
24899 }
24900
ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24901 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24902 {
24903 USE_OPLINE
24904 zval *varptr, *arg;
24905
24906 if (IS_CONST == IS_CONST) {
24907 SAVE_OPLINE();
24908 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24909 uint32_t arg_num;
24910 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
24911 if (UNEXPECTED(!arg)) {
24912 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24913 HANDLE_EXCEPTION();
24914 }
24915 } else {
24916 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
24917 }
24918
24919 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24920 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
24921 SAVE_OPLINE();
24922 ZVAL_UNDEFINED_OP1();
24923 ZVAL_NULL(arg);
24924 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24925 }
24926
24927 if (IS_VAR == IS_CV) {
24928 ZVAL_COPY_DEREF(arg, varptr);
24929 } else /* if (IS_VAR == IS_VAR) */ {
24930 if (UNEXPECTED(Z_ISREF_P(varptr))) {
24931 zend_refcounted *ref = Z_COUNTED_P(varptr);
24932
24933 varptr = Z_REFVAL_P(varptr);
24934 ZVAL_COPY_VALUE(arg, varptr);
24935 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
24936 efree_size(ref, sizeof(zend_reference));
24937 } else if (Z_OPT_REFCOUNTED_P(arg)) {
24938 Z_ADDREF_P(arg);
24939 }
24940 } else {
24941 ZVAL_COPY_VALUE(arg, varptr);
24942 }
24943 }
24944
24945 ZEND_VM_NEXT_OPCODE();
24946 }
24947
ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24948 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24949 {
24950 USE_OPLINE
24951 zval *varptr, *arg;
24952
24953 if (IS_CONST == IS_CONST) {
24954 SAVE_OPLINE();
24955 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24956 uint32_t arg_num;
24957 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
24958 if (UNEXPECTED(!arg)) {
24959 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24960 HANDLE_EXCEPTION();
24961 }
24962 } else {
24963 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
24964 }
24965
24966 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24967 ZVAL_COPY_VALUE(arg, varptr);
24968
24969 if (EXPECTED(Z_ISREF_P(varptr))) {
24970 ZEND_VM_NEXT_OPCODE();
24971 }
24972
24973 SAVE_OPLINE();
24974 ZVAL_NEW_REF(arg, arg);
24975 zend_error(E_NOTICE, "Only variables should be passed by reference");
24976 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24977 }
24978
ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24979 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24980 {
24981 USE_OPLINE
24982 zval *varptr, *arg;
24983 uint32_t arg_num;
24984
24985 if (IS_CONST == IS_CONST) {
24986 SAVE_OPLINE();
24987 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24988 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
24989 if (UNEXPECTED(!arg)) {
24990 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24991 HANDLE_EXCEPTION();
24992 }
24993 } else {
24994 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
24995 arg_num = opline->op2.num;
24996 }
24997
24998 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
24999 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25000 goto send_var;
25001 }
25002
25003 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25004 ZVAL_COPY_VALUE(arg, varptr);
25005
25006 if (EXPECTED(Z_ISREF_P(varptr) ||
25007 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25008 ZEND_VM_NEXT_OPCODE();
25009 }
25010 } else {
25011 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25012 goto send_var;
25013 }
25014
25015 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25016 ZVAL_COPY_VALUE(arg, varptr);
25017
25018 if (EXPECTED(Z_ISREF_P(varptr) ||
25019 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25020 ZEND_VM_NEXT_OPCODE();
25021 }
25022 }
25023
25024 SAVE_OPLINE();
25025 ZVAL_NEW_REF(arg, arg);
25026 zend_error(E_NOTICE, "Only variables should be passed by reference");
25027 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25028
25029 send_var:
25030 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25031 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25032 zend_refcounted *ref = Z_COUNTED_P(varptr);
25033
25034 varptr = Z_REFVAL_P(varptr);
25035 ZVAL_COPY_VALUE(arg, varptr);
25036 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25037 efree_size(ref, sizeof(zend_reference));
25038 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25039 Z_ADDREF_P(arg);
25040 }
25041 } else {
25042 ZVAL_COPY_VALUE(arg, varptr);
25043 }
25044 ZEND_VM_NEXT_OPCODE();
25045 }
25046
ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25047 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25048 {
25049 USE_OPLINE
25050 zval *varptr, *arg;
25051
25052 SAVE_OPLINE();
25053 if (IS_CONST == IS_CONST) {
25054 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25055 uint32_t arg_num;
25056 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25057 if (UNEXPECTED(!arg)) {
25058 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25059 HANDLE_EXCEPTION();
25060 }
25061 } else {
25062 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25063 }
25064
25065 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25066 if (Z_ISREF_P(varptr)) {
25067 Z_ADDREF_P(varptr);
25068 } else {
25069 ZVAL_MAKE_REF_EX(varptr, 2);
25070 }
25071 ZVAL_REF(arg, Z_REF_P(varptr));
25072
25073 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25074 ZEND_VM_NEXT_OPCODE();
25075 }
25076
ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25077 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25078 {
25079 USE_OPLINE
25080 zval *varptr, *arg;
25081 uint32_t arg_num;
25082
25083 if (IS_CONST == IS_CONST) {
25084 SAVE_OPLINE();
25085 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25086 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25087 if (UNEXPECTED(!arg)) {
25088 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25089 HANDLE_EXCEPTION();
25090 }
25091 } else {
25092 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25093 arg_num = opline->op2.num;
25094 }
25095
25096 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
25097 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25098 goto send_var_by_ref;
25099 }
25100 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25101 send_var_by_ref:
25102 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25103 if (Z_ISREF_P(varptr)) {
25104 Z_ADDREF_P(varptr);
25105 } else {
25106 ZVAL_MAKE_REF_EX(varptr, 2);
25107 }
25108 ZVAL_REF(arg, Z_REF_P(varptr));
25109
25110 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25111 ZEND_VM_NEXT_OPCODE();
25112 }
25113
25114 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25115 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
25116 SAVE_OPLINE();
25117 ZVAL_UNDEFINED_OP1();
25118 ZVAL_NULL(arg);
25119 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25120 }
25121
25122 if (IS_VAR == IS_CV) {
25123 ZVAL_COPY_DEREF(arg, varptr);
25124 } else /* if (IS_VAR == IS_VAR) */ {
25125 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25126 zend_refcounted *ref = Z_COUNTED_P(varptr);
25127
25128 varptr = Z_REFVAL_P(varptr);
25129 ZVAL_COPY_VALUE(arg, varptr);
25130 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25131 efree_size(ref, sizeof(zend_reference));
25132 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25133 Z_ADDREF_P(arg);
25134 }
25135 } else {
25136 ZVAL_COPY_VALUE(arg, varptr);
25137 }
25138 }
25139
25140 ZEND_VM_NEXT_OPCODE();
25141 }
25142
ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25143 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25144 {
25145 USE_OPLINE
25146 zval *varptr, *arg;
25147
25148 if (IS_CONST == IS_CONST) {
25149 // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
25150 SAVE_OPLINE();
25151 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25152 uint32_t arg_num;
25153 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25154 if (UNEXPECTED(!arg)) {
25155 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25156 HANDLE_EXCEPTION();
25157 }
25158 } else {
25159 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25160 }
25161
25162 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
25163 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25164 if (Z_ISREF_P(varptr)) {
25165 Z_ADDREF_P(varptr);
25166 } else {
25167 ZVAL_MAKE_REF_EX(varptr, 2);
25168 }
25169 ZVAL_REF(arg, Z_REF_P(varptr));
25170
25171 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25172 ZEND_VM_NEXT_OPCODE();
25173 }
25174
25175 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25176
25177 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25178 zend_refcounted *ref = Z_COUNTED_P(varptr);
25179
25180 varptr = Z_REFVAL_P(varptr);
25181 ZVAL_COPY_VALUE(arg, varptr);
25182 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25183 efree_size(ref, sizeof(zend_reference));
25184 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25185 Z_ADDREF_P(arg);
25186 }
25187 } else {
25188 ZVAL_COPY_VALUE(arg, varptr);
25189 }
25190
25191 ZEND_VM_NEXT_OPCODE();
25192 }
25193
ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25194 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25195 {
25196 zend_class_entry *ce, *scope;
25197 zend_class_constant *c;
25198 zval *value, *zv, *constant_zv;
25199 zend_string *constant_name;
25200 USE_OPLINE
25201
25202 SAVE_OPLINE();
25203
25204 do {
25205 if (IS_VAR == IS_CONST && IS_CONST == IS_CONST) {
25206 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
25207 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25208 break;
25209 }
25210 }
25211 if (IS_VAR == IS_CONST) {
25212 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
25213 ce = CACHED_PTR(opline->extended_value);
25214 } else {
25215 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);
25216 if (UNEXPECTED(ce == NULL)) {
25217 ZVAL_UNDEF(EX_VAR(opline->result.var));
25218
25219 HANDLE_EXCEPTION();
25220 }
25221 CACHE_PTR(opline->extended_value, ce);
25222 }
25223 } else if (IS_VAR == IS_UNUSED) {
25224 ce = zend_fetch_class(NULL, opline->op1.num);
25225 if (UNEXPECTED(ce == NULL)) {
25226 ZVAL_UNDEF(EX_VAR(opline->result.var));
25227
25228 HANDLE_EXCEPTION();
25229 }
25230 } else {
25231 ce = Z_CE_P(EX_VAR(opline->op1.var));
25232 }
25233 if (IS_VAR != IS_CONST
25234 && IS_CONST == IS_CONST
25235 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
25236 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25237 break;
25238 }
25239
25240 constant_zv = RT_CONSTANT(opline, opline->op2);
25241 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
25242 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
25243 ZVAL_UNDEF(EX_VAR(opline->result.var));
25244
25245 HANDLE_EXCEPTION();
25246 }
25247 constant_name = Z_STR_P(constant_zv);
25248 /* Magic 'class' for constant OP2 is caught at compile-time */
25249 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
25250 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
25251
25252 ZEND_VM_NEXT_OPCODE();
25253 }
25254 zv = IS_CONST == IS_CONST
25255 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
25256 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
25257
25258 if (EXPECTED(zv != NULL)) {
25259 c = Z_PTR_P(zv);
25260 scope = EX(func)->op_array.scope;
25261 if (!zend_verify_const_access(c, scope)) {
25262 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));
25263 ZVAL_UNDEF(EX_VAR(opline->result.var));
25264
25265 HANDLE_EXCEPTION();
25266 }
25267
25268 if (ce->ce_flags & ZEND_ACC_TRAIT) {
25269 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25270 ZVAL_UNDEF(EX_VAR(opline->result.var));
25271
25272 HANDLE_EXCEPTION();
25273 }
25274
25275 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
25276 if (UNEXPECTED(is_constant_deprecated)) {
25277 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25278
25279 if (EG(exception)) {
25280 ZVAL_UNDEF(EX_VAR(opline->result.var));
25281
25282 HANDLE_EXCEPTION();
25283 }
25284 }
25285
25286 value = &c->value;
25287 // Enums require loading of all class constants to build the backed enum table
25288 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)) {
25289 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
25290 ZVAL_UNDEF(EX_VAR(opline->result.var));
25291
25292 HANDLE_EXCEPTION();
25293 }
25294 }
25295 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
25296 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
25297 ZVAL_UNDEF(EX_VAR(opline->result.var));
25298
25299 HANDLE_EXCEPTION();
25300 }
25301 }
25302 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
25303 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
25304 }
25305 } else {
25306 zend_throw_error(NULL, "Undefined constant %s::%s",
25307 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25308 ZVAL_UNDEF(EX_VAR(opline->result.var));
25309
25310 HANDLE_EXCEPTION();
25311 }
25312 } while (0);
25313
25314 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
25315
25316 ZEND_VM_NEXT_OPCODE();
25317 }
25318
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25319 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25320 {
25321 USE_OPLINE
25322 zval *expr_ptr, new_expr;
25323
25324 SAVE_OPLINE();
25325 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
25326 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
25327 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25328 if (Z_ISREF_P(expr_ptr)) {
25329 Z_ADDREF_P(expr_ptr);
25330 } else {
25331 ZVAL_MAKE_REF_EX(expr_ptr, 2);
25332 }
25333 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25334 } else {
25335 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25336 if (IS_VAR == IS_TMP_VAR) {
25337 /* pass */
25338 } else if (IS_VAR == IS_CONST) {
25339 Z_TRY_ADDREF_P(expr_ptr);
25340 } else if (IS_VAR == IS_CV) {
25341 ZVAL_DEREF(expr_ptr);
25342 Z_TRY_ADDREF_P(expr_ptr);
25343 } else /* if (IS_VAR == IS_VAR) */ {
25344 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
25345 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
25346
25347 expr_ptr = Z_REFVAL_P(expr_ptr);
25348 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25349 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
25350 expr_ptr = &new_expr;
25351 efree_size(ref, sizeof(zend_reference));
25352 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
25353 Z_ADDREF_P(expr_ptr);
25354 }
25355 }
25356 }
25357 }
25358
25359 if (IS_CONST != IS_UNUSED) {
25360 zval *offset = RT_CONSTANT(opline, opline->op2);
25361 zend_string *str;
25362 zend_ulong hval;
25363
25364 add_again:
25365 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
25366 str = Z_STR_P(offset);
25367 if (IS_CONST != IS_CONST) {
25368 if (ZEND_HANDLE_NUMERIC(str, hval)) {
25369 goto num_index;
25370 }
25371 }
25372 str_index:
25373 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
25374 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
25375 hval = Z_LVAL_P(offset);
25376 num_index:
25377 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
25378 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
25379 offset = Z_REFVAL_P(offset);
25380 goto add_again;
25381 } else if (Z_TYPE_P(offset) == IS_NULL) {
25382 str = ZSTR_EMPTY_ALLOC();
25383 goto str_index;
25384 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
25385 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
25386 goto num_index;
25387 } else if (Z_TYPE_P(offset) == IS_FALSE) {
25388 hval = 0;
25389 goto num_index;
25390 } else if (Z_TYPE_P(offset) == IS_TRUE) {
25391 hval = 1;
25392 goto num_index;
25393 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
25394 zend_use_resource_as_offset(offset);
25395 hval = Z_RES_HANDLE_P(offset);
25396 goto num_index;
25397 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
25398 ZVAL_UNDEFINED_OP2();
25399 str = ZSTR_EMPTY_ALLOC();
25400 goto str_index;
25401 } else {
25402 zend_illegal_array_offset_access(offset);
25403 zval_ptr_dtor_nogc(expr_ptr);
25404 }
25405
25406 } else {
25407 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
25408 zend_cannot_add_element();
25409 zval_ptr_dtor_nogc(expr_ptr);
25410 }
25411 }
25412 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25413 }
25414
ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25415 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25416 {
25417 zval *array;
25418 uint32_t size;
25419 USE_OPLINE
25420
25421 array = EX_VAR(opline->result.var);
25422 if (IS_VAR != IS_UNUSED) {
25423 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
25424 ZVAL_ARR(array, zend_new_array(size));
25425 /* Explicitly initialize array as not-packed if flag is set */
25426 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
25427 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
25428 }
25429 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
25430 } else {
25431 ZVAL_ARR(array, zend_new_array(0));
25432 ZEND_VM_NEXT_OPCODE();
25433 }
25434 }
25435
ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25436 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25437 {
25438 USE_OPLINE
25439 zval *container;
25440 zval *offset;
25441 zend_ulong hval;
25442 zend_string *key;
25443
25444 SAVE_OPLINE();
25445 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25446 offset = RT_CONSTANT(opline, opline->op2);
25447
25448 do {
25449 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
25450 HashTable *ht;
25451
25452 unset_dim_array:
25453 SEPARATE_ARRAY(container);
25454 ht = Z_ARRVAL_P(container);
25455 offset_again:
25456 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
25457 key = Z_STR_P(offset);
25458 if (IS_CONST != IS_CONST) {
25459 if (ZEND_HANDLE_NUMERIC(key, hval)) {
25460 goto num_index_dim;
25461 }
25462 }
25463 str_index_dim:
25464 ZEND_ASSERT(ht != &EG(symbol_table));
25465 zend_hash_del(ht, key);
25466 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
25467 hval = Z_LVAL_P(offset);
25468 num_index_dim:
25469 zend_hash_index_del(ht, hval);
25470 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
25471 offset = Z_REFVAL_P(offset);
25472 goto offset_again;
25473 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
25474 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
25475 goto num_index_dim;
25476 } else if (Z_TYPE_P(offset) == IS_NULL) {
25477 key = ZSTR_EMPTY_ALLOC();
25478 goto str_index_dim;
25479 } else if (Z_TYPE_P(offset) == IS_FALSE) {
25480 hval = 0;
25481 goto num_index_dim;
25482 } else if (Z_TYPE_P(offset) == IS_TRUE) {
25483 hval = 1;
25484 goto num_index_dim;
25485 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
25486 zend_use_resource_as_offset(offset);
25487 hval = Z_RES_HANDLE_P(offset);
25488 goto num_index_dim;
25489 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
25490 ZVAL_UNDEFINED_OP2();
25491 key = ZSTR_EMPTY_ALLOC();
25492 goto str_index_dim;
25493 } else {
25494 zend_illegal_array_offset_unset(offset);
25495 }
25496 break;
25497 } else if (Z_ISREF_P(container)) {
25498 container = Z_REFVAL_P(container);
25499 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
25500 goto unset_dim_array;
25501 }
25502 }
25503 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
25504 container = ZVAL_UNDEFINED_OP1();
25505 }
25506 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
25507 offset = ZVAL_UNDEFINED_OP2();
25508 }
25509 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
25510 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
25511 offset++;
25512 }
25513 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
25514 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
25515 zend_throw_error(NULL, "Cannot unset string offsets");
25516 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
25517 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
25518 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
25519 zend_false_to_array_deprecated();
25520 }
25521 } while (0);
25522
25523 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25524 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25525 }
25526
ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25527 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25528 {
25529 USE_OPLINE
25530 zval *container;
25531 zval *offset;
25532 zend_string *name, *tmp_name;
25533
25534 SAVE_OPLINE();
25535 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25536 offset = RT_CONSTANT(opline, opline->op2);
25537
25538 do {
25539 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
25540 if (Z_ISREF_P(container)) {
25541 container = Z_REFVAL_P(container);
25542 if (Z_TYPE_P(container) != IS_OBJECT) {
25543 if (IS_VAR == IS_CV
25544 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
25545 ZVAL_UNDEFINED_OP1();
25546 }
25547 break;
25548 }
25549 } else {
25550 break;
25551 }
25552 }
25553 if (IS_CONST == IS_CONST) {
25554 name = Z_STR_P(offset);
25555 } else {
25556 name = zval_try_get_tmp_string(offset, &tmp_name);
25557 if (UNEXPECTED(!name)) {
25558 break;
25559 }
25560 }
25561 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
25562 if (IS_CONST != IS_CONST) {
25563 zend_tmp_string_release(tmp_name);
25564 }
25565 } while (0);
25566
25567 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25568 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25569 }
25570
ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25571 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25572 {
25573 USE_OPLINE
25574
25575 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
25576
25577 SAVE_OPLINE();
25578 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
25579 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
25580 }
25581
25582 /* Destroy the previously yielded value */
25583 zval_ptr_dtor(&generator->value);
25584
25585 /* Destroy the previously yielded key */
25586 zval_ptr_dtor(&generator->key);
25587
25588 /* Set the new yielded value */
25589 if (IS_VAR != IS_UNUSED) {
25590 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
25591 /* Constants and temporary variables aren't yieldable by reference,
25592 * but we still allow them with a notice. */
25593 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
25594 zval *value;
25595
25596 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
25597
25598 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25599 ZVAL_COPY_VALUE(&generator->value, value);
25600 if (IS_VAR == IS_CONST) {
25601 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
25602 Z_ADDREF(generator->value);
25603 }
25604 }
25605 } else {
25606 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25607
25608 /* If a function call result is yielded and the function did
25609 * not return by reference we throw a notice. */
25610 do {
25611 if (IS_VAR == IS_VAR) {
25612 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
25613 if (opline->extended_value == ZEND_RETURNS_FUNCTION
25614 && !Z_ISREF_P(value_ptr)) {
25615 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
25616 ZVAL_COPY(&generator->value, value_ptr);
25617 break;
25618 }
25619 }
25620 if (Z_ISREF_P(value_ptr)) {
25621 Z_ADDREF_P(value_ptr);
25622 } else {
25623 ZVAL_MAKE_REF_EX(value_ptr, 2);
25624 }
25625 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
25626 } while (0);
25627
25628 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25629 }
25630 } else {
25631 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25632
25633 /* Consts, temporary variables and references need copying */
25634 if (IS_VAR == IS_CONST) {
25635 ZVAL_COPY_VALUE(&generator->value, value);
25636 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
25637 Z_ADDREF(generator->value);
25638 }
25639 } else if (IS_VAR == IS_TMP_VAR) {
25640 ZVAL_COPY_VALUE(&generator->value, value);
25641 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
25642 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
25643 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25644 } else {
25645 ZVAL_COPY_VALUE(&generator->value, value);
25646 if (IS_VAR == IS_CV) {
25647 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
25648 }
25649 }
25650 }
25651 } else {
25652 /* If no value was specified yield null */
25653 ZVAL_NULL(&generator->value);
25654 }
25655
25656 /* Set the new yielded key */
25657 if (IS_CONST != IS_UNUSED) {
25658 zval *key = RT_CONSTANT(opline, opline->op2);
25659 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
25660 key = Z_REFVAL_P(key);
25661 }
25662 ZVAL_COPY(&generator->key, key);
25663
25664 if (Z_TYPE(generator->key) == IS_LONG
25665 && Z_LVAL(generator->key) > generator->largest_used_integer_key
25666 ) {
25667 generator->largest_used_integer_key = Z_LVAL(generator->key);
25668 }
25669 } else {
25670 /* If no key was specified we use auto-increment keys */
25671 generator->largest_used_integer_key++;
25672 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
25673 }
25674
25675 if (RETURN_VALUE_USED(opline)) {
25676 /* If the return value of yield is used set the send
25677 * target and initialize it to NULL */
25678 generator->send_target = EX_VAR(opline->result.var);
25679 ZVAL_NULL(generator->send_target);
25680 } else {
25681 generator->send_target = NULL;
25682 }
25683
25684 /* We increment to the next op, so we are at the correct position when the
25685 * generator is resumed. */
25686 ZEND_VM_INC_OPCODE();
25687
25688 /* The GOTO VM uses a local opline variable. We need to set the opline
25689 * variable in execute_data so we don't resume at an old position. */
25690 SAVE_OPLINE();
25691
25692 ZEND_VM_RETURN();
25693 }
25694
ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25695 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25696 {
25697 USE_OPLINE
25698 zval *op1;
25699 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
25700 zval *result;
25701
25702 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25703 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
25704 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_VAR == IS_CONST);
25705 if (IS_VAR & (IS_TMP_VAR|IS_VAR)) {
25706 zval_ptr_dtor_str(op1);
25707 }
25708 ZEND_VM_SMART_BRANCH(result, 0);
25709 }
25710
25711 if (opline->extended_value) {
25712 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
25713 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
25714 ZEND_VM_SMART_BRANCH(result, 0);
25715 }
25716 SAVE_OPLINE();
25717 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
25718 op1 = Z_REFVAL_P(op1);
25719 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
25720 result = zend_hash_find(ht, Z_STR_P(op1));
25721 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25722 ZEND_VM_SMART_BRANCH(result, 0);
25723 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
25724 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
25725 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25726 ZEND_VM_SMART_BRANCH(result, 0);
25727 }
25728 } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
25729 ZVAL_UNDEFINED_OP1();
25730 }
25731 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
25732 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
25733 SAVE_OPLINE();
25734 ZVAL_UNDEFINED_OP1();
25735 if (UNEXPECTED(EG(exception) != NULL)) {
25736 HANDLE_EXCEPTION();
25737 }
25738 }
25739 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
25740 ZEND_VM_SMART_BRANCH(result, 0);
25741 } else {
25742 zend_string *key;
25743 zval key_tmp;
25744
25745 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
25746 op1 = Z_REFVAL_P(op1);
25747 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
25748 result = zend_hash_find(ht, Z_STR_P(op1));
25749 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25750 ZEND_VM_SMART_BRANCH(result, 0);
25751 }
25752 }
25753
25754 SAVE_OPLINE();
25755 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
25756 ZVAL_STR(&key_tmp, key);
25757 if (zend_compare(op1, &key_tmp) == 0) {
25758 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25759 ZEND_VM_SMART_BRANCH(1, 1);
25760 }
25761 } ZEND_HASH_FOREACH_END();
25762 }
25763 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25764 ZEND_VM_SMART_BRANCH(0, 1);
25765 }
25766
ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25767 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25768 {
25769 zend_class_entry *ce, *scope;
25770 zend_class_constant *c;
25771 zval *value, *zv, *constant_zv;
25772 zend_string *constant_name;
25773 USE_OPLINE
25774
25775 SAVE_OPLINE();
25776
25777 do {
25778 if (IS_VAR == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
25779 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
25780 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25781 break;
25782 }
25783 }
25784 if (IS_VAR == IS_CONST) {
25785 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
25786 ce = CACHED_PTR(opline->extended_value);
25787 } else {
25788 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);
25789 if (UNEXPECTED(ce == NULL)) {
25790 ZVAL_UNDEF(EX_VAR(opline->result.var));
25791 FREE_OP(opline->op2_type, opline->op2.var);
25792 HANDLE_EXCEPTION();
25793 }
25794 CACHE_PTR(opline->extended_value, ce);
25795 }
25796 } else if (IS_VAR == IS_UNUSED) {
25797 ce = zend_fetch_class(NULL, opline->op1.num);
25798 if (UNEXPECTED(ce == NULL)) {
25799 ZVAL_UNDEF(EX_VAR(opline->result.var));
25800 FREE_OP(opline->op2_type, opline->op2.var);
25801 HANDLE_EXCEPTION();
25802 }
25803 } else {
25804 ce = Z_CE_P(EX_VAR(opline->op1.var));
25805 }
25806 if (IS_VAR != IS_CONST
25807 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
25808 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
25809 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25810 break;
25811 }
25812
25813 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
25814 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
25815 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
25816 ZVAL_UNDEF(EX_VAR(opline->result.var));
25817 FREE_OP(opline->op2_type, opline->op2.var);
25818 HANDLE_EXCEPTION();
25819 }
25820 constant_name = Z_STR_P(constant_zv);
25821 /* Magic 'class' for constant OP2 is caught at compile-time */
25822 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
25823 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
25824 FREE_OP(opline->op2_type, opline->op2.var);
25825 ZEND_VM_NEXT_OPCODE();
25826 }
25827 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
25828 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
25829 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
25830
25831 if (EXPECTED(zv != NULL)) {
25832 c = Z_PTR_P(zv);
25833 scope = EX(func)->op_array.scope;
25834 if (!zend_verify_const_access(c, scope)) {
25835 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));
25836 ZVAL_UNDEF(EX_VAR(opline->result.var));
25837 FREE_OP(opline->op2_type, opline->op2.var);
25838 HANDLE_EXCEPTION();
25839 }
25840
25841 if (ce->ce_flags & ZEND_ACC_TRAIT) {
25842 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25843 ZVAL_UNDEF(EX_VAR(opline->result.var));
25844 FREE_OP(opline->op2_type, opline->op2.var);
25845 HANDLE_EXCEPTION();
25846 }
25847
25848 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
25849 if (UNEXPECTED(is_constant_deprecated)) {
25850 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25851
25852 if (EG(exception)) {
25853 ZVAL_UNDEF(EX_VAR(opline->result.var));
25854 FREE_OP(opline->op2_type, opline->op2.var);
25855 HANDLE_EXCEPTION();
25856 }
25857 }
25858
25859 value = &c->value;
25860 // Enums require loading of all class constants to build the backed enum table
25861 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)) {
25862 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
25863 ZVAL_UNDEF(EX_VAR(opline->result.var));
25864 FREE_OP(opline->op2_type, opline->op2.var);
25865 HANDLE_EXCEPTION();
25866 }
25867 }
25868 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
25869 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
25870 ZVAL_UNDEF(EX_VAR(opline->result.var));
25871 FREE_OP(opline->op2_type, opline->op2.var);
25872 HANDLE_EXCEPTION();
25873 }
25874 }
25875 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
25876 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
25877 }
25878 } else {
25879 zend_throw_error(NULL, "Undefined constant %s::%s",
25880 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25881 ZVAL_UNDEF(EX_VAR(opline->result.var));
25882 FREE_OP(opline->op2_type, opline->op2.var);
25883 HANDLE_EXCEPTION();
25884 }
25885 } while (0);
25886
25887 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
25888
25889 FREE_OP(opline->op2_type, opline->op2.var);
25890 ZEND_VM_NEXT_OPCODE();
25891 }
25892
ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25893 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25894 {
25895 USE_OPLINE
25896 zval *object;
25897 zval *property;
25898 zval *value;
25899 zval *zptr;
25900 void **cache_slot;
25901 zend_property_info *prop_info;
25902 zend_object *zobj;
25903 zend_string *name, *tmp_name;
25904
25905 SAVE_OPLINE();
25906 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25907 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
25908
25909 do {
25910 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
25911
25912 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
25913 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
25914 object = Z_REFVAL_P(object);
25915 goto assign_op_object;
25916 }
25917 if (IS_VAR == IS_CV
25918 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
25919 ZVAL_UNDEFINED_OP1();
25920 }
25921 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
25922 break;
25923 }
25924
25925 assign_op_object:
25926 /* here we are sure we are dealing with an object */
25927 zobj = Z_OBJ_P(object);
25928 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
25929 name = Z_STR_P(property);
25930 } else {
25931 name = zval_try_get_tmp_string(property, &tmp_name);
25932 if (UNEXPECTED(!name)) {
25933 UNDEF_RESULT();
25934 break;
25935 }
25936 }
25937 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
25938 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
25939 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
25940 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25941 ZVAL_NULL(EX_VAR(opline->result.var));
25942 }
25943 } else {
25944 zval *orig_zptr = zptr;
25945 zend_reference *ref;
25946
25947 do {
25948 if (UNEXPECTED(Z_ISREF_P(zptr))) {
25949 ref = Z_REF_P(zptr);
25950 zptr = Z_REFVAL_P(zptr);
25951 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
25952 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
25953 break;
25954 }
25955 }
25956
25957 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
25958 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
25959 } else {
25960 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
25961 }
25962 if (prop_info) {
25963 /* special case for typed properties */
25964 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
25965 } else {
25966 zend_binary_op(zptr, zptr, value OPLINE_CC);
25967 }
25968 } while (0);
25969
25970 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25971 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
25972 }
25973 }
25974 } else {
25975 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
25976 }
25977 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
25978 zend_tmp_string_release(tmp_name);
25979 }
25980 } while (0);
25981
25982 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
25983 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
25984 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25985 /* assign_obj has two opcodes! */
25986 ZEND_VM_NEXT_OPCODE_EX(1, 2);
25987 }
25988
25989 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25990 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25991 {
25992 USE_OPLINE
25993 zval *var_ptr;
25994 zval *value, *container, *dim;
25995 HashTable *ht;
25996
25997 SAVE_OPLINE();
25998 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25999
26000 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26001 assign_dim_op_array:
26002 SEPARATE_ARRAY(container);
26003 ht = Z_ARRVAL_P(container);
26004 assign_dim_op_new_array:
26005 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26006 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26007 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
26008 if (UNEXPECTED(!var_ptr)) {
26009 zend_cannot_add_element();
26010 goto assign_dim_op_ret_null;
26011 }
26012 } else {
26013 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26014 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
26015 } else {
26016 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
26017 }
26018 if (UNEXPECTED(!var_ptr)) {
26019 goto assign_dim_op_ret_null;
26020 }
26021 }
26022
26023 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
26024
26025 do {
26026 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
26027 zend_reference *ref = Z_REF_P(var_ptr);
26028 var_ptr = Z_REFVAL_P(var_ptr);
26029 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26030 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26031 break;
26032 }
26033 }
26034 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26035 } while (0);
26036
26037 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26038 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26039 }
26040 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26041 } else {
26042 if (EXPECTED(Z_ISREF_P(container))) {
26043 container = Z_REFVAL_P(container);
26044 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26045 goto assign_dim_op_array;
26046 }
26047 }
26048
26049 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
26050 zend_object *obj = Z_OBJ_P(container);
26051
26052 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26053 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
26054 dim++;
26055 }
26056 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
26057 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
26058 uint8_t old_type;
26059
26060 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
26061 ZVAL_UNDEFINED_OP1();
26062 }
26063 ht = zend_new_array(8);
26064 old_type = Z_TYPE_P(container);
26065 ZVAL_ARR(container, ht);
26066 if (UNEXPECTED(old_type == IS_FALSE)) {
26067 GC_ADDREF(ht);
26068 zend_false_to_array_deprecated();
26069 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
26070 zend_array_destroy(ht);
26071 goto assign_dim_op_ret_null;
26072 }
26073 }
26074 goto assign_dim_op_new_array;
26075 } else {
26076 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26077 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
26078 assign_dim_op_ret_null:
26079 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26080 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26081 ZVAL_NULL(EX_VAR(opline->result.var));
26082 }
26083 }
26084 }
26085
26086 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26087 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26088 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26089 }
26090
ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26091 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26092 {
26093 USE_OPLINE
26094 zval *var_ptr;
26095 zval *value;
26096
26097 SAVE_OPLINE();
26098 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26099 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26100
26101 do {
26102 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
26103 zend_reference *ref = Z_REF_P(var_ptr);
26104 var_ptr = Z_REFVAL_P(var_ptr);
26105 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26106 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26107 break;
26108 }
26109 }
26110 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26111 } while (0);
26112
26113 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26114 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26115 }
26116
26117 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26118 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26119 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26120 }
26121
ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26122 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26123 {
26124 USE_OPLINE
26125 zval *object;
26126 zval *property;
26127 zval *zptr;
26128 void **cache_slot;
26129 zend_property_info *prop_info;
26130 zend_object *zobj;
26131 zend_string *name, *tmp_name;
26132
26133 SAVE_OPLINE();
26134 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26135 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26136
26137 do {
26138 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26139 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26140 object = Z_REFVAL_P(object);
26141 goto pre_incdec_object;
26142 }
26143 if (IS_VAR == IS_CV
26144 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26145 ZVAL_UNDEFINED_OP1();
26146 }
26147 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26148 break;
26149 }
26150
26151 pre_incdec_object:
26152 /* here we are sure we are dealing with an object */
26153 zobj = Z_OBJ_P(object);
26154 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26155 name = Z_STR_P(property);
26156 } else {
26157 name = zval_try_get_tmp_string(property, &tmp_name);
26158 if (UNEXPECTED(!name)) {
26159 UNDEF_RESULT();
26160 break;
26161 }
26162 }
26163 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
26164 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26165 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26166 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26167 ZVAL_NULL(EX_VAR(opline->result.var));
26168 }
26169 } else {
26170 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26171 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
26172 } else {
26173 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
26174 }
26175 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26176 }
26177 } else {
26178 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26179 }
26180 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26181 zend_tmp_string_release(tmp_name);
26182 }
26183 } while (0);
26184
26185 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26186 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26187 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26188 }
26189
ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26190 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26191 {
26192 USE_OPLINE
26193 zval *object;
26194 zval *property;
26195 zval *zptr;
26196 void **cache_slot;
26197 zend_property_info *prop_info;
26198 zend_object *zobj;
26199 zend_string *name, *tmp_name;
26200
26201 SAVE_OPLINE();
26202 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26203 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26204
26205 do {
26206 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26207 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26208 object = Z_REFVAL_P(object);
26209 goto post_incdec_object;
26210 }
26211 if (IS_VAR == IS_CV
26212 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26213 ZVAL_UNDEFINED_OP1();
26214 }
26215 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26216 break;
26217 }
26218
26219 post_incdec_object:
26220 /* here we are sure we are dealing with an object */
26221 zobj = Z_OBJ_P(object);
26222 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26223 name = Z_STR_P(property);
26224 } else {
26225 name = zval_try_get_tmp_string(property, &tmp_name);
26226 if (UNEXPECTED(!name)) {
26227 ZVAL_UNDEF(EX_VAR(opline->result.var));
26228 break;
26229 }
26230 }
26231 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
26232 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26233 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26234 ZVAL_NULL(EX_VAR(opline->result.var));
26235 } else {
26236 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26237 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
26238 } else {
26239 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
26240 }
26241
26242 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26243 }
26244 } else {
26245 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26246 }
26247 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26248 zend_tmp_string_release(tmp_name);
26249 }
26250 } while (0);
26251
26252 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26253 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26254 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26255 }
26256
ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26257 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26258 {
26259 USE_OPLINE
26260 zval *container;
26261
26262 SAVE_OPLINE();
26263 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26264 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);
26265 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26266 if (IS_VAR == IS_VAR) {
26267 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26268 }
26269 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26270 }
26271
ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26272 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26273 {
26274 USE_OPLINE
26275 zval *container;
26276
26277 SAVE_OPLINE();
26278 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26279 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);
26280 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26281 if (IS_VAR == IS_VAR) {
26282 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26283 }
26284 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26285 }
26286
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26287 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26288 {
26289 #if 0
26290 USE_OPLINE
26291 #endif
26292
26293 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
26294 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
26295 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26296 }
26297 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26298 } else {
26299 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26300 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26301 }
26302 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26303 }
26304 }
26305
ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26306 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26307 {
26308 USE_OPLINE
26309 zval *container;
26310
26311 SAVE_OPLINE();
26312 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26313 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);
26314 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26315 if (IS_VAR == IS_VAR) {
26316 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26317 }
26318 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26319 }
26320
ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26321 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26322 {
26323 USE_OPLINE
26324 zval *property, *container, *result;
26325
26326 SAVE_OPLINE();
26327
26328 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26329 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26330 result = EX_VAR(opline->result.var);
26331 zend_fetch_property_address(
26332 result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR),
26333 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
26334 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
26335 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26336 if (IS_VAR == IS_VAR) {
26337 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26338 }
26339 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26340 }
26341
ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26342 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26343 {
26344 USE_OPLINE
26345 zval *property, *container, *result;
26346
26347 SAVE_OPLINE();
26348 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26349 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26350 result = EX_VAR(opline->result.var);
26351 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);
26352 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26353 if (IS_VAR == IS_VAR) {
26354 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26355 }
26356 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26357 }
26358
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26359 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26360 {
26361 #if 0
26362 USE_OPLINE
26363 #endif
26364
26365 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
26366 /* Behave like FETCH_OBJ_W */
26367 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
26368 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26369 }
26370 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26371 } else {
26372 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26373 }
26374 }
26375
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26376 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26377 {
26378 USE_OPLINE
26379 zval *container, *property, *result;
26380
26381 SAVE_OPLINE();
26382 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26383 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26384 result = EX_VAR(opline->result.var);
26385 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);
26386 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26387 if (IS_VAR == IS_VAR) {
26388 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26389 }
26390 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26391 }
26392
ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26393 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26394 {
26395 USE_OPLINE
26396 zval *container, *dim;
26397
26398 SAVE_OPLINE();
26399 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26400 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26401
26402 if (IS_VAR == IS_VAR
26403 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
26404 && UNEXPECTED(!Z_ISREF_P(container))
26405 ) {
26406 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
26407 zend_fetch_dimension_address_LIST_r(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
26408 } else {
26409 zend_fetch_dimension_address_W(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
26410 }
26411
26412 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26413 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26414 }
26415
ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26416 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26417 {
26418 USE_OPLINE
26419 zval *object, *value, tmp;
26420 zend_object *zobj;
26421 zend_string *name, *tmp_name;
26422 zend_refcounted *garbage = NULL;
26423
26424 SAVE_OPLINE();
26425 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26426 value = RT_CONSTANT((opline+1), (opline+1)->op1);
26427
26428 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26429 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26430 object = Z_REFVAL_P(object);
26431 goto assign_object;
26432 }
26433 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
26434 value = &EG(uninitialized_zval);
26435 goto free_and_exit_assign_obj;
26436 }
26437
26438 assign_object:
26439 zobj = Z_OBJ_P(object);
26440 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26441 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
26442 void **cache_slot = CACHE_ADDR(opline->extended_value);
26443 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
26444 zval *property_val;
26445
26446 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
26447 property_val = OBJ_PROP(zobj, prop_offset);
26448 if (Z_TYPE_P(property_val) != IS_UNDEF) {
26449 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
26450
26451 if (prop_info != NULL) {
26452 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
26453 goto free_and_exit_assign_obj;
26454 } else {
26455 fast_assign_obj:
26456 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
26457 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26458 ZVAL_COPY(EX_VAR(opline->result.var), value);
26459 }
26460 goto exit_assign_obj;
26461 }
26462 }
26463 } else {
26464 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26465 if (EXPECTED(zobj->properties != NULL)) {
26466 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
26467 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
26468 GC_DELREF(zobj->properties);
26469 }
26470 zobj->properties = zend_array_dup(zobj->properties);
26471 }
26472 property_val = zend_hash_find_known_hash(zobj->properties, name);
26473 if (property_val) {
26474 goto fast_assign_obj;
26475 }
26476 }
26477
26478 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
26479 if (EXPECTED(zobj->properties == NULL)) {
26480 rebuild_object_properties(zobj);
26481 }
26482 if (IS_CONST == IS_CONST) {
26483 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
26484 Z_ADDREF_P(value);
26485 }
26486 } else if (IS_CONST != IS_TMP_VAR) {
26487 if (Z_ISREF_P(value)) {
26488 if (IS_CONST == IS_VAR) {
26489 zend_reference *ref = Z_REF_P(value);
26490 if (GC_DELREF(ref) == 0) {
26491 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
26492 efree_size(ref, sizeof(zend_reference));
26493 value = &tmp;
26494 } else {
26495 value = Z_REFVAL_P(value);
26496 Z_TRY_ADDREF_P(value);
26497 }
26498 } else {
26499 value = Z_REFVAL_P(value);
26500 Z_TRY_ADDREF_P(value);
26501 }
26502 } else if (IS_CONST == IS_CV) {
26503 Z_TRY_ADDREF_P(value);
26504 }
26505 }
26506 zend_hash_add_new(zobj->properties, name, value);
26507 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26508 ZVAL_COPY(EX_VAR(opline->result.var), value);
26509 }
26510 goto exit_assign_obj;
26511 }
26512 }
26513 }
26514 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26515 } else {
26516 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
26517 if (UNEXPECTED(!name)) {
26518
26519 UNDEF_RESULT();
26520 goto exit_assign_obj;
26521 }
26522 }
26523
26524 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
26525 ZVAL_DEREF(value);
26526 }
26527
26528 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
26529
26530 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26531 zend_tmp_string_release(tmp_name);
26532 }
26533
26534 free_and_exit_assign_obj:
26535 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
26536 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
26537 }
26538
26539 exit_assign_obj:
26540 if (garbage) {
26541 GC_DTOR_NO_REF(garbage);
26542 }
26543 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26544 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26545 /* assign_obj has two opcodes! */
26546 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26547 }
26548
26549 /* 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)26550 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26551 {
26552 USE_OPLINE
26553 zval *object, *value, tmp;
26554 zend_object *zobj;
26555 zend_string *name, *tmp_name;
26556 zend_refcounted *garbage = NULL;
26557
26558 SAVE_OPLINE();
26559 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26560 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
26561
26562 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26563 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26564 object = Z_REFVAL_P(object);
26565 goto assign_object;
26566 }
26567 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
26568 value = &EG(uninitialized_zval);
26569 goto free_and_exit_assign_obj;
26570 }
26571
26572 assign_object:
26573 zobj = Z_OBJ_P(object);
26574 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26575 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
26576 void **cache_slot = CACHE_ADDR(opline->extended_value);
26577 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
26578 zval *property_val;
26579
26580 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
26581 property_val = OBJ_PROP(zobj, prop_offset);
26582 if (Z_TYPE_P(property_val) != IS_UNDEF) {
26583 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
26584
26585 if (prop_info != NULL) {
26586 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
26587 goto free_and_exit_assign_obj;
26588 } else {
26589 fast_assign_obj:
26590 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
26591 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26592 ZVAL_COPY(EX_VAR(opline->result.var), value);
26593 }
26594 goto exit_assign_obj;
26595 }
26596 }
26597 } else {
26598 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26599 if (EXPECTED(zobj->properties != NULL)) {
26600 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
26601 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
26602 GC_DELREF(zobj->properties);
26603 }
26604 zobj->properties = zend_array_dup(zobj->properties);
26605 }
26606 property_val = zend_hash_find_known_hash(zobj->properties, name);
26607 if (property_val) {
26608 goto fast_assign_obj;
26609 }
26610 }
26611
26612 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
26613 if (EXPECTED(zobj->properties == NULL)) {
26614 rebuild_object_properties(zobj);
26615 }
26616 if (IS_TMP_VAR == IS_CONST) {
26617 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
26618 Z_ADDREF_P(value);
26619 }
26620 } else if (IS_TMP_VAR != IS_TMP_VAR) {
26621 if (Z_ISREF_P(value)) {
26622 if (IS_TMP_VAR == IS_VAR) {
26623 zend_reference *ref = Z_REF_P(value);
26624 if (GC_DELREF(ref) == 0) {
26625 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
26626 efree_size(ref, sizeof(zend_reference));
26627 value = &tmp;
26628 } else {
26629 value = Z_REFVAL_P(value);
26630 Z_TRY_ADDREF_P(value);
26631 }
26632 } else {
26633 value = Z_REFVAL_P(value);
26634 Z_TRY_ADDREF_P(value);
26635 }
26636 } else if (IS_TMP_VAR == IS_CV) {
26637 Z_TRY_ADDREF_P(value);
26638 }
26639 }
26640 zend_hash_add_new(zobj->properties, name, value);
26641 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26642 ZVAL_COPY(EX_VAR(opline->result.var), value);
26643 }
26644 goto exit_assign_obj;
26645 }
26646 }
26647 }
26648 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26649 } else {
26650 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
26651 if (UNEXPECTED(!name)) {
26652 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
26653 UNDEF_RESULT();
26654 goto exit_assign_obj;
26655 }
26656 }
26657
26658 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
26659 ZVAL_DEREF(value);
26660 }
26661
26662 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
26663
26664 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26665 zend_tmp_string_release(tmp_name);
26666 }
26667
26668 free_and_exit_assign_obj:
26669 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
26670 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
26671 }
26672 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
26673 exit_assign_obj:
26674 if (garbage) {
26675 GC_DTOR_NO_REF(garbage);
26676 }
26677 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26678 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26679 /* assign_obj has two opcodes! */
26680 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26681 }
26682
26683 /* 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)26684 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26685 {
26686 USE_OPLINE
26687 zval *object, *value, tmp;
26688 zend_object *zobj;
26689 zend_string *name, *tmp_name;
26690 zend_refcounted *garbage = NULL;
26691
26692 SAVE_OPLINE();
26693 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26694 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
26695
26696 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26697 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26698 object = Z_REFVAL_P(object);
26699 goto assign_object;
26700 }
26701 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
26702 value = &EG(uninitialized_zval);
26703 goto free_and_exit_assign_obj;
26704 }
26705
26706 assign_object:
26707 zobj = Z_OBJ_P(object);
26708 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26709 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
26710 void **cache_slot = CACHE_ADDR(opline->extended_value);
26711 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
26712 zval *property_val;
26713
26714 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
26715 property_val = OBJ_PROP(zobj, prop_offset);
26716 if (Z_TYPE_P(property_val) != IS_UNDEF) {
26717 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
26718
26719 if (prop_info != NULL) {
26720 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
26721 goto free_and_exit_assign_obj;
26722 } else {
26723 fast_assign_obj:
26724 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
26725 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26726 ZVAL_COPY(EX_VAR(opline->result.var), value);
26727 }
26728 goto exit_assign_obj;
26729 }
26730 }
26731 } else {
26732 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26733 if (EXPECTED(zobj->properties != NULL)) {
26734 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
26735 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
26736 GC_DELREF(zobj->properties);
26737 }
26738 zobj->properties = zend_array_dup(zobj->properties);
26739 }
26740 property_val = zend_hash_find_known_hash(zobj->properties, name);
26741 if (property_val) {
26742 goto fast_assign_obj;
26743 }
26744 }
26745
26746 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
26747 if (EXPECTED(zobj->properties == NULL)) {
26748 rebuild_object_properties(zobj);
26749 }
26750 if (IS_VAR == IS_CONST) {
26751 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
26752 Z_ADDREF_P(value);
26753 }
26754 } else if (IS_VAR != IS_TMP_VAR) {
26755 if (Z_ISREF_P(value)) {
26756 if (IS_VAR == IS_VAR) {
26757 zend_reference *ref = Z_REF_P(value);
26758 if (GC_DELREF(ref) == 0) {
26759 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
26760 efree_size(ref, sizeof(zend_reference));
26761 value = &tmp;
26762 } else {
26763 value = Z_REFVAL_P(value);
26764 Z_TRY_ADDREF_P(value);
26765 }
26766 } else {
26767 value = Z_REFVAL_P(value);
26768 Z_TRY_ADDREF_P(value);
26769 }
26770 } else if (IS_VAR == IS_CV) {
26771 Z_TRY_ADDREF_P(value);
26772 }
26773 }
26774 zend_hash_add_new(zobj->properties, name, value);
26775 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26776 ZVAL_COPY(EX_VAR(opline->result.var), value);
26777 }
26778 goto exit_assign_obj;
26779 }
26780 }
26781 }
26782 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26783 } else {
26784 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
26785 if (UNEXPECTED(!name)) {
26786 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
26787 UNDEF_RESULT();
26788 goto exit_assign_obj;
26789 }
26790 }
26791
26792 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
26793 ZVAL_DEREF(value);
26794 }
26795
26796 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
26797
26798 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26799 zend_tmp_string_release(tmp_name);
26800 }
26801
26802 free_and_exit_assign_obj:
26803 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
26804 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
26805 }
26806 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
26807 exit_assign_obj:
26808 if (garbage) {
26809 GC_DTOR_NO_REF(garbage);
26810 }
26811 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26812 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26813 /* assign_obj has two opcodes! */
26814 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26815 }
26816
26817 /* 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)26818 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26819 {
26820 USE_OPLINE
26821 zval *object, *value, tmp;
26822 zend_object *zobj;
26823 zend_string *name, *tmp_name;
26824 zend_refcounted *garbage = NULL;
26825
26826 SAVE_OPLINE();
26827 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26828 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
26829
26830 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26831 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26832 object = Z_REFVAL_P(object);
26833 goto assign_object;
26834 }
26835 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
26836 value = &EG(uninitialized_zval);
26837 goto free_and_exit_assign_obj;
26838 }
26839
26840 assign_object:
26841 zobj = Z_OBJ_P(object);
26842 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26843 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
26844 void **cache_slot = CACHE_ADDR(opline->extended_value);
26845 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
26846 zval *property_val;
26847
26848 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
26849 property_val = OBJ_PROP(zobj, prop_offset);
26850 if (Z_TYPE_P(property_val) != IS_UNDEF) {
26851 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
26852
26853 if (prop_info != NULL) {
26854 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
26855 goto free_and_exit_assign_obj;
26856 } else {
26857 fast_assign_obj:
26858 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
26859 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26860 ZVAL_COPY(EX_VAR(opline->result.var), value);
26861 }
26862 goto exit_assign_obj;
26863 }
26864 }
26865 } else {
26866 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26867 if (EXPECTED(zobj->properties != NULL)) {
26868 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
26869 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
26870 GC_DELREF(zobj->properties);
26871 }
26872 zobj->properties = zend_array_dup(zobj->properties);
26873 }
26874 property_val = zend_hash_find_known_hash(zobj->properties, name);
26875 if (property_val) {
26876 goto fast_assign_obj;
26877 }
26878 }
26879
26880 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
26881 if (EXPECTED(zobj->properties == NULL)) {
26882 rebuild_object_properties(zobj);
26883 }
26884 if (IS_CV == IS_CONST) {
26885 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
26886 Z_ADDREF_P(value);
26887 }
26888 } else if (IS_CV != IS_TMP_VAR) {
26889 if (Z_ISREF_P(value)) {
26890 if (IS_CV == IS_VAR) {
26891 zend_reference *ref = Z_REF_P(value);
26892 if (GC_DELREF(ref) == 0) {
26893 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
26894 efree_size(ref, sizeof(zend_reference));
26895 value = &tmp;
26896 } else {
26897 value = Z_REFVAL_P(value);
26898 Z_TRY_ADDREF_P(value);
26899 }
26900 } else {
26901 value = Z_REFVAL_P(value);
26902 Z_TRY_ADDREF_P(value);
26903 }
26904 } else if (IS_CV == IS_CV) {
26905 Z_TRY_ADDREF_P(value);
26906 }
26907 }
26908 zend_hash_add_new(zobj->properties, name, value);
26909 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26910 ZVAL_COPY(EX_VAR(opline->result.var), value);
26911 }
26912 goto exit_assign_obj;
26913 }
26914 }
26915 }
26916 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26917 } else {
26918 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
26919 if (UNEXPECTED(!name)) {
26920
26921 UNDEF_RESULT();
26922 goto exit_assign_obj;
26923 }
26924 }
26925
26926 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
26927 ZVAL_DEREF(value);
26928 }
26929
26930 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
26931
26932 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26933 zend_tmp_string_release(tmp_name);
26934 }
26935
26936 free_and_exit_assign_obj:
26937 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
26938 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
26939 }
26940
26941 exit_assign_obj:
26942 if (garbage) {
26943 GC_DTOR_NO_REF(garbage);
26944 }
26945 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26946 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26947 /* assign_obj has two opcodes! */
26948 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26949 }
26950
26951 /* 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)26952 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26953 {
26954 USE_OPLINE
26955 zval *object_ptr, *orig_object_ptr;
26956 zval *value;
26957 zval *variable_ptr;
26958 zval *dim;
26959 zend_refcounted *garbage = NULL;
26960
26961 SAVE_OPLINE();
26962 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26963
26964 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
26965 try_assign_dim_array:
26966 SEPARATE_ARRAY(object_ptr);
26967 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26968 value = RT_CONSTANT((opline+1), (opline+1)->op1);
26969 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
26970 HashTable *ht = Z_ARRVAL_P(object_ptr);
26971 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
26972 GC_ADDREF(ht);
26973 }
26974 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
26975 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
26976 zend_array_destroy(ht);
26977 goto assign_dim_error;
26978 }
26979 }
26980 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
26981 ZVAL_DEREF(value);
26982 }
26983 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
26984 if (UNEXPECTED(value == NULL)) {
26985 zend_cannot_add_element();
26986 goto assign_dim_error;
26987 } else if (IS_CONST == IS_CV) {
26988 if (Z_REFCOUNTED_P(value)) {
26989 Z_ADDREF_P(value);
26990 }
26991 } else if (IS_CONST == IS_VAR) {
26992 zval *free_op_data = EX_VAR((opline+1)->op1.var);
26993 if (Z_ISREF_P(free_op_data)) {
26994 if (Z_REFCOUNTED_P(value)) {
26995 Z_ADDREF_P(value);
26996 }
26997 zval_ptr_dtor_nogc(free_op_data);
26998 }
26999 } else if (IS_CONST == IS_CONST) {
27000 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27001 Z_ADDREF_P(value);
27002 }
27003 }
27004 } else {
27005 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27006 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27007 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27008 } else {
27009 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27010 }
27011 if (UNEXPECTED(variable_ptr == NULL)) {
27012 goto assign_dim_error;
27013 }
27014 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27015 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
27016 }
27017 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27018 ZVAL_COPY(EX_VAR(opline->result.var), value);
27019 }
27020 if (garbage) {
27021 GC_DTOR_NO_REF(garbage);
27022 }
27023 } else {
27024 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27025 object_ptr = Z_REFVAL_P(object_ptr);
27026 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27027 goto try_assign_dim_array;
27028 }
27029 }
27030 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27031 zend_object *obj = Z_OBJ_P(object_ptr);
27032
27033 GC_ADDREF(obj);
27034 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27035 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27036 dim = ZVAL_UNDEFINED_OP2();
27037 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27038 dim++;
27039 }
27040
27041 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27042 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27043 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27044 } else if (IS_CONST & (IS_CV|IS_VAR)) {
27045 ZVAL_DEREF(value);
27046 }
27047
27048 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27049
27050 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27051 zend_objects_store_del(obj);
27052 }
27053 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27054 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27055 zend_use_new_element_for_string();
27056
27057 UNDEF_RESULT();
27058 } else {
27059 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27060 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27061 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27062
27063 }
27064 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27065 if (Z_ISREF_P(orig_object_ptr)
27066 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27067 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27068 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27069
27070 UNDEF_RESULT();
27071 } else {
27072 HashTable *ht = zend_new_array(8);
27073 uint8_t old_type = Z_TYPE_P(object_ptr);
27074
27075 ZVAL_ARR(object_ptr, ht);
27076 if (UNEXPECTED(old_type == IS_FALSE)) {
27077 GC_ADDREF(ht);
27078 zend_false_to_array_deprecated();
27079 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27080 zend_array_destroy(ht);
27081 goto assign_dim_error;
27082 }
27083 }
27084 goto try_assign_dim_array;
27085 }
27086 } else {
27087 zend_use_scalar_as_array();
27088 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27089 assign_dim_error:
27090
27091 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27092 ZVAL_NULL(EX_VAR(opline->result.var));
27093 }
27094 }
27095 }
27096 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27097 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27098 }
27099 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27100 /* assign_dim has two opcodes! */
27101 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27102 }
27103
ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27104 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27105 {
27106 USE_OPLINE
27107 zval *object_ptr, *orig_object_ptr;
27108 zval *value;
27109 zval *variable_ptr;
27110 zval *dim;
27111 zend_refcounted *garbage = NULL;
27112
27113 SAVE_OPLINE();
27114 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27115
27116 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27117 try_assign_dim_array:
27118 SEPARATE_ARRAY(object_ptr);
27119 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27120 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27121 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27122 HashTable *ht = Z_ARRVAL_P(object_ptr);
27123 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27124 GC_ADDREF(ht);
27125 }
27126 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27127 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27128 zend_array_destroy(ht);
27129 goto assign_dim_error;
27130 }
27131 }
27132 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27133 ZVAL_DEREF(value);
27134 }
27135 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27136 if (UNEXPECTED(value == NULL)) {
27137 zend_cannot_add_element();
27138 goto assign_dim_error;
27139 } else if (IS_TMP_VAR == IS_CV) {
27140 if (Z_REFCOUNTED_P(value)) {
27141 Z_ADDREF_P(value);
27142 }
27143 } else if (IS_TMP_VAR == IS_VAR) {
27144 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27145 if (Z_ISREF_P(free_op_data)) {
27146 if (Z_REFCOUNTED_P(value)) {
27147 Z_ADDREF_P(value);
27148 }
27149 zval_ptr_dtor_nogc(free_op_data);
27150 }
27151 } else if (IS_TMP_VAR == IS_CONST) {
27152 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27153 Z_ADDREF_P(value);
27154 }
27155 }
27156 } else {
27157 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27158 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27159 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27160 } else {
27161 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27162 }
27163 if (UNEXPECTED(variable_ptr == NULL)) {
27164 goto assign_dim_error;
27165 }
27166 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27167 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
27168 }
27169 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27170 ZVAL_COPY(EX_VAR(opline->result.var), value);
27171 }
27172 if (garbage) {
27173 GC_DTOR_NO_REF(garbage);
27174 }
27175 } else {
27176 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27177 object_ptr = Z_REFVAL_P(object_ptr);
27178 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27179 goto try_assign_dim_array;
27180 }
27181 }
27182 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27183 zend_object *obj = Z_OBJ_P(object_ptr);
27184
27185 GC_ADDREF(obj);
27186 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27187 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27188 dim = ZVAL_UNDEFINED_OP2();
27189 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27190 dim++;
27191 }
27192
27193 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27194 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27195 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27196 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
27197 ZVAL_DEREF(value);
27198 }
27199
27200 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27201
27202 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27203 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27204 zend_objects_store_del(obj);
27205 }
27206 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27207 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27208 zend_use_new_element_for_string();
27209 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27210 UNDEF_RESULT();
27211 } else {
27212 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27213 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27214 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27215 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27216 }
27217 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27218 if (Z_ISREF_P(orig_object_ptr)
27219 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27220 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27221 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27222 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27223 UNDEF_RESULT();
27224 } else {
27225 HashTable *ht = zend_new_array(8);
27226 uint8_t old_type = Z_TYPE_P(object_ptr);
27227
27228 ZVAL_ARR(object_ptr, ht);
27229 if (UNEXPECTED(old_type == IS_FALSE)) {
27230 GC_ADDREF(ht);
27231 zend_false_to_array_deprecated();
27232 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27233 zend_array_destroy(ht);
27234 goto assign_dim_error;
27235 }
27236 }
27237 goto try_assign_dim_array;
27238 }
27239 } else {
27240 zend_use_scalar_as_array();
27241 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27242 assign_dim_error:
27243 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27244 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27245 ZVAL_NULL(EX_VAR(opline->result.var));
27246 }
27247 }
27248 }
27249 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27250 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27251 }
27252 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27253 /* assign_dim has two opcodes! */
27254 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27255 }
27256
ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27257 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27258 {
27259 USE_OPLINE
27260 zval *object_ptr, *orig_object_ptr;
27261 zval *value;
27262 zval *variable_ptr;
27263 zval *dim;
27264 zend_refcounted *garbage = NULL;
27265
27266 SAVE_OPLINE();
27267 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27268
27269 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27270 try_assign_dim_array:
27271 SEPARATE_ARRAY(object_ptr);
27272 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27273 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27274 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27275 HashTable *ht = Z_ARRVAL_P(object_ptr);
27276 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27277 GC_ADDREF(ht);
27278 }
27279 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27280 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27281 zend_array_destroy(ht);
27282 goto assign_dim_error;
27283 }
27284 }
27285 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
27286 ZVAL_DEREF(value);
27287 }
27288 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27289 if (UNEXPECTED(value == NULL)) {
27290 zend_cannot_add_element();
27291 goto assign_dim_error;
27292 } else if (IS_VAR == IS_CV) {
27293 if (Z_REFCOUNTED_P(value)) {
27294 Z_ADDREF_P(value);
27295 }
27296 } else if (IS_VAR == IS_VAR) {
27297 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27298 if (Z_ISREF_P(free_op_data)) {
27299 if (Z_REFCOUNTED_P(value)) {
27300 Z_ADDREF_P(value);
27301 }
27302 zval_ptr_dtor_nogc(free_op_data);
27303 }
27304 } else if (IS_VAR == IS_CONST) {
27305 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27306 Z_ADDREF_P(value);
27307 }
27308 }
27309 } else {
27310 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27311 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27312 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27313 } else {
27314 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27315 }
27316 if (UNEXPECTED(variable_ptr == NULL)) {
27317 goto assign_dim_error;
27318 }
27319 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27320 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
27321 }
27322 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27323 ZVAL_COPY(EX_VAR(opline->result.var), value);
27324 }
27325 if (garbage) {
27326 GC_DTOR_NO_REF(garbage);
27327 }
27328 } else {
27329 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27330 object_ptr = Z_REFVAL_P(object_ptr);
27331 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27332 goto try_assign_dim_array;
27333 }
27334 }
27335 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27336 zend_object *obj = Z_OBJ_P(object_ptr);
27337
27338 GC_ADDREF(obj);
27339 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27340 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27341 dim = ZVAL_UNDEFINED_OP2();
27342 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27343 dim++;
27344 }
27345
27346 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27347 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27348 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27349 } else if (IS_VAR & (IS_CV|IS_VAR)) {
27350 ZVAL_DEREF(value);
27351 }
27352
27353 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27354
27355 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27356 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27357 zend_objects_store_del(obj);
27358 }
27359 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27360 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27361 zend_use_new_element_for_string();
27362 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27363 UNDEF_RESULT();
27364 } else {
27365 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27366 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27367 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27368 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27369 }
27370 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27371 if (Z_ISREF_P(orig_object_ptr)
27372 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27373 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27374 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27375 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27376 UNDEF_RESULT();
27377 } else {
27378 HashTable *ht = zend_new_array(8);
27379 uint8_t old_type = Z_TYPE_P(object_ptr);
27380
27381 ZVAL_ARR(object_ptr, ht);
27382 if (UNEXPECTED(old_type == IS_FALSE)) {
27383 GC_ADDREF(ht);
27384 zend_false_to_array_deprecated();
27385 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27386 zend_array_destroy(ht);
27387 goto assign_dim_error;
27388 }
27389 }
27390 goto try_assign_dim_array;
27391 }
27392 } else {
27393 zend_use_scalar_as_array();
27394 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27395 assign_dim_error:
27396 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27397 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27398 ZVAL_NULL(EX_VAR(opline->result.var));
27399 }
27400 }
27401 }
27402 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27403 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27404 }
27405 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27406 /* assign_dim has two opcodes! */
27407 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27408 }
27409
ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27410 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27411 {
27412 USE_OPLINE
27413 zval *object_ptr, *orig_object_ptr;
27414 zval *value;
27415 zval *variable_ptr;
27416 zval *dim;
27417 zend_refcounted *garbage = NULL;
27418
27419 SAVE_OPLINE();
27420 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27421
27422 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27423 try_assign_dim_array:
27424 SEPARATE_ARRAY(object_ptr);
27425 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27426 value = EX_VAR((opline+1)->op1.var);
27427 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27428 HashTable *ht = Z_ARRVAL_P(object_ptr);
27429 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27430 GC_ADDREF(ht);
27431 }
27432 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27433 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27434 zend_array_destroy(ht);
27435 goto assign_dim_error;
27436 }
27437 }
27438 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
27439 ZVAL_DEREF(value);
27440 }
27441 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27442 if (UNEXPECTED(value == NULL)) {
27443 zend_cannot_add_element();
27444 goto assign_dim_error;
27445 } else if (IS_CV == IS_CV) {
27446 if (Z_REFCOUNTED_P(value)) {
27447 Z_ADDREF_P(value);
27448 }
27449 } else if (IS_CV == IS_VAR) {
27450 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27451 if (Z_ISREF_P(free_op_data)) {
27452 if (Z_REFCOUNTED_P(value)) {
27453 Z_ADDREF_P(value);
27454 }
27455 zval_ptr_dtor_nogc(free_op_data);
27456 }
27457 } else if (IS_CV == IS_CONST) {
27458 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27459 Z_ADDREF_P(value);
27460 }
27461 }
27462 } else {
27463 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27464 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27465 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27466 } else {
27467 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27468 }
27469 if (UNEXPECTED(variable_ptr == NULL)) {
27470 goto assign_dim_error;
27471 }
27472 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
27473 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
27474 }
27475 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27476 ZVAL_COPY(EX_VAR(opline->result.var), value);
27477 }
27478 if (garbage) {
27479 GC_DTOR_NO_REF(garbage);
27480 }
27481 } else {
27482 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27483 object_ptr = Z_REFVAL_P(object_ptr);
27484 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27485 goto try_assign_dim_array;
27486 }
27487 }
27488 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27489 zend_object *obj = Z_OBJ_P(object_ptr);
27490
27491 GC_ADDREF(obj);
27492 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27493 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27494 dim = ZVAL_UNDEFINED_OP2();
27495 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27496 dim++;
27497 }
27498
27499 value = EX_VAR((opline+1)->op1.var);
27500 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27501 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27502 } else if (IS_CV & (IS_CV|IS_VAR)) {
27503 ZVAL_DEREF(value);
27504 }
27505
27506 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27507
27508 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27509 zend_objects_store_del(obj);
27510 }
27511 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27512 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27513 zend_use_new_element_for_string();
27514
27515 UNDEF_RESULT();
27516 } else {
27517 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27518 value = EX_VAR((opline+1)->op1.var);
27519 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27520
27521 }
27522 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27523 if (Z_ISREF_P(orig_object_ptr)
27524 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27525 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27526 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27527
27528 UNDEF_RESULT();
27529 } else {
27530 HashTable *ht = zend_new_array(8);
27531 uint8_t old_type = Z_TYPE_P(object_ptr);
27532
27533 ZVAL_ARR(object_ptr, ht);
27534 if (UNEXPECTED(old_type == IS_FALSE)) {
27535 GC_ADDREF(ht);
27536 zend_false_to_array_deprecated();
27537 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27538 zend_array_destroy(ht);
27539 goto assign_dim_error;
27540 }
27541 }
27542 goto try_assign_dim_array;
27543 }
27544 } else {
27545 zend_use_scalar_as_array();
27546 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27547 assign_dim_error:
27548
27549 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27550 ZVAL_NULL(EX_VAR(opline->result.var));
27551 }
27552 }
27553 }
27554 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27555 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27556 }
27557 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27558 /* assign_dim has two opcodes! */
27559 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27560 }
27561
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27562 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27563 {
27564 USE_OPLINE
27565 zval *property, *container, *value_ptr;
27566
27567 SAVE_OPLINE();
27568
27569 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27570 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27571
27572 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27573
27574 if (1) {
27575 if (IS_VAR == IS_UNUSED) {
27576 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27577 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27578 } else {
27579 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27580 }
27581 } else {
27582 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27583 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27584 } else {
27585 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27586 }
27587 }
27588 } else {
27589 zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
27590 }
27591
27592 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27593 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27594 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27595 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27596 }
27597
27598 /* 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)27599 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27600 {
27601 USE_OPLINE
27602 zval *property, *container, *value_ptr;
27603
27604 SAVE_OPLINE();
27605
27606 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27607 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27608
27609 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
27610
27611 if (1) {
27612 if (IS_VAR == IS_UNUSED) {
27613 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27614 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27615 } else {
27616 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27617 }
27618 } else {
27619 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27620 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27621 } else {
27622 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27623 }
27624 }
27625 } else {
27626 zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
27627 }
27628
27629 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27630 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27631
27632 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27633 }
27634
27635 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27636 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27637 {
27638 USE_OPLINE
27639 zval *function_name;
27640 zend_class_entry *ce;
27641 uint32_t call_info;
27642 zend_function *fbc;
27643 zend_execute_data *call;
27644
27645 SAVE_OPLINE();
27646
27647 if (IS_VAR == IS_CONST) {
27648 /* no function found. try a static method in class */
27649 ce = CACHED_PTR(opline->result.num);
27650 if (UNEXPECTED(ce == NULL)) {
27651 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);
27652 if (UNEXPECTED(ce == NULL)) {
27653 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27654 HANDLE_EXCEPTION();
27655 }
27656 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27657 CACHE_PTR(opline->result.num, ce);
27658 }
27659 }
27660 } else if (IS_VAR == IS_UNUSED) {
27661 ce = zend_fetch_class(NULL, opline->op1.num);
27662 if (UNEXPECTED(ce == NULL)) {
27663 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27664 HANDLE_EXCEPTION();
27665 }
27666 } else {
27667 ce = Z_CE_P(EX_VAR(opline->op1.var));
27668 }
27669
27670 if (IS_VAR == IS_CONST &&
27671 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
27672 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
27673 /* nothing to do */
27674 } else if (IS_VAR != IS_CONST &&
27675 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
27676 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
27677 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
27678 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27679 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27680 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27681 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
27682 do {
27683 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
27684 function_name = Z_REFVAL_P(function_name);
27685 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
27686 break;
27687 }
27688 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
27689 ZVAL_UNDEFINED_OP2();
27690 if (UNEXPECTED(EG(exception) != NULL)) {
27691 HANDLE_EXCEPTION();
27692 }
27693 }
27694 zend_throw_error(NULL, "Method name must be a string");
27695 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27696 HANDLE_EXCEPTION();
27697 } while (0);
27698 }
27699 }
27700
27701 if (ce->get_static_method) {
27702 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
27703 } else {
27704 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));
27705 }
27706 if (UNEXPECTED(fbc == NULL)) {
27707 if (EXPECTED(!EG(exception))) {
27708 zend_undefined_method(ce, Z_STR_P(function_name));
27709 }
27710 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27711 HANDLE_EXCEPTION();
27712 }
27713 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
27714 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
27715 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
27716 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
27717 }
27718 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
27719 init_func_run_time_cache(&fbc->op_array);
27720 }
27721 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27722 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27723 }
27724 } else {
27725 if (UNEXPECTED(ce->constructor == NULL)) {
27726 zend_throw_error(NULL, "Cannot call constructor");
27727 HANDLE_EXCEPTION();
27728 }
27729 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
27730 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
27731 HANDLE_EXCEPTION();
27732 }
27733 fbc = ce->constructor;
27734 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
27735 init_func_run_time_cache(&fbc->op_array);
27736 }
27737 }
27738
27739 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
27740 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
27741 ce = (zend_class_entry*)Z_OBJ(EX(This));
27742 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
27743 } else {
27744 zend_non_static_method_call(fbc);
27745 HANDLE_EXCEPTION();
27746 }
27747 } else {
27748 /* previous opcode is ZEND_FETCH_CLASS */
27749 if (IS_VAR == IS_UNUSED
27750 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
27751 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
27752 if (Z_TYPE(EX(This)) == IS_OBJECT) {
27753 ce = Z_OBJCE(EX(This));
27754 } else {
27755 ce = Z_CE(EX(This));
27756 }
27757 }
27758 call_info = ZEND_CALL_NESTED_FUNCTION;
27759 }
27760
27761 call = zend_vm_stack_push_call_frame(call_info,
27762 fbc, opline->extended_value, ce);
27763 call->prev_execute_data = EX(call);
27764 EX(call) = call;
27765
27766 ZEND_VM_NEXT_OPCODE();
27767 }
27768
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27769 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27770 {
27771 USE_OPLINE
27772 zval *expr_ptr, new_expr;
27773
27774 SAVE_OPLINE();
27775 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
27776 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
27777 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27778 if (Z_ISREF_P(expr_ptr)) {
27779 Z_ADDREF_P(expr_ptr);
27780 } else {
27781 ZVAL_MAKE_REF_EX(expr_ptr, 2);
27782 }
27783 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27784 } else {
27785 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27786 if (IS_VAR == IS_TMP_VAR) {
27787 /* pass */
27788 } else if (IS_VAR == IS_CONST) {
27789 Z_TRY_ADDREF_P(expr_ptr);
27790 } else if (IS_VAR == IS_CV) {
27791 ZVAL_DEREF(expr_ptr);
27792 Z_TRY_ADDREF_P(expr_ptr);
27793 } else /* if (IS_VAR == IS_VAR) */ {
27794 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
27795 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
27796
27797 expr_ptr = Z_REFVAL_P(expr_ptr);
27798 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
27799 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
27800 expr_ptr = &new_expr;
27801 efree_size(ref, sizeof(zend_reference));
27802 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
27803 Z_ADDREF_P(expr_ptr);
27804 }
27805 }
27806 }
27807 }
27808
27809 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27810 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27811 zend_string *str;
27812 zend_ulong hval;
27813
27814 add_again:
27815 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
27816 str = Z_STR_P(offset);
27817 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27818 if (ZEND_HANDLE_NUMERIC(str, hval)) {
27819 goto num_index;
27820 }
27821 }
27822 str_index:
27823 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
27824 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
27825 hval = Z_LVAL_P(offset);
27826 num_index:
27827 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
27828 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
27829 offset = Z_REFVAL_P(offset);
27830 goto add_again;
27831 } else if (Z_TYPE_P(offset) == IS_NULL) {
27832 str = ZSTR_EMPTY_ALLOC();
27833 goto str_index;
27834 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
27835 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
27836 goto num_index;
27837 } else if (Z_TYPE_P(offset) == IS_FALSE) {
27838 hval = 0;
27839 goto num_index;
27840 } else if (Z_TYPE_P(offset) == IS_TRUE) {
27841 hval = 1;
27842 goto num_index;
27843 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
27844 zend_use_resource_as_offset(offset);
27845 hval = Z_RES_HANDLE_P(offset);
27846 goto num_index;
27847 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
27848 ZVAL_UNDEFINED_OP2();
27849 str = ZSTR_EMPTY_ALLOC();
27850 goto str_index;
27851 } else {
27852 zend_illegal_array_offset_access(offset);
27853 zval_ptr_dtor_nogc(expr_ptr);
27854 }
27855 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27856 } else {
27857 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
27858 zend_cannot_add_element();
27859 zval_ptr_dtor_nogc(expr_ptr);
27860 }
27861 }
27862 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27863 }
27864
ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27865 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27866 {
27867 zval *array;
27868 uint32_t size;
27869 USE_OPLINE
27870
27871 array = EX_VAR(opline->result.var);
27872 if (IS_VAR != IS_UNUSED) {
27873 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
27874 ZVAL_ARR(array, zend_new_array(size));
27875 /* Explicitly initialize array as not-packed if flag is set */
27876 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
27877 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
27878 }
27879 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27880 } else {
27881 ZVAL_ARR(array, zend_new_array(0));
27882 ZEND_VM_NEXT_OPCODE();
27883 }
27884 }
27885
ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27886 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27887 {
27888 USE_OPLINE
27889 zval *container;
27890 zval *offset;
27891 zend_ulong hval;
27892 zend_string *key;
27893
27894 SAVE_OPLINE();
27895 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27896 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27897
27898 do {
27899 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
27900 HashTable *ht;
27901
27902 unset_dim_array:
27903 SEPARATE_ARRAY(container);
27904 ht = Z_ARRVAL_P(container);
27905 offset_again:
27906 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
27907 key = Z_STR_P(offset);
27908 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27909 if (ZEND_HANDLE_NUMERIC(key, hval)) {
27910 goto num_index_dim;
27911 }
27912 }
27913 str_index_dim:
27914 ZEND_ASSERT(ht != &EG(symbol_table));
27915 zend_hash_del(ht, key);
27916 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
27917 hval = Z_LVAL_P(offset);
27918 num_index_dim:
27919 zend_hash_index_del(ht, hval);
27920 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
27921 offset = Z_REFVAL_P(offset);
27922 goto offset_again;
27923 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
27924 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
27925 goto num_index_dim;
27926 } else if (Z_TYPE_P(offset) == IS_NULL) {
27927 key = ZSTR_EMPTY_ALLOC();
27928 goto str_index_dim;
27929 } else if (Z_TYPE_P(offset) == IS_FALSE) {
27930 hval = 0;
27931 goto num_index_dim;
27932 } else if (Z_TYPE_P(offset) == IS_TRUE) {
27933 hval = 1;
27934 goto num_index_dim;
27935 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
27936 zend_use_resource_as_offset(offset);
27937 hval = Z_RES_HANDLE_P(offset);
27938 goto num_index_dim;
27939 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
27940 ZVAL_UNDEFINED_OP2();
27941 key = ZSTR_EMPTY_ALLOC();
27942 goto str_index_dim;
27943 } else {
27944 zend_illegal_array_offset_unset(offset);
27945 }
27946 break;
27947 } else if (Z_ISREF_P(container)) {
27948 container = Z_REFVAL_P(container);
27949 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
27950 goto unset_dim_array;
27951 }
27952 }
27953 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
27954 container = ZVAL_UNDEFINED_OP1();
27955 }
27956 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
27957 offset = ZVAL_UNDEFINED_OP2();
27958 }
27959 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
27960 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
27961 offset++;
27962 }
27963 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
27964 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
27965 zend_throw_error(NULL, "Cannot unset string offsets");
27966 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
27967 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
27968 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
27969 zend_false_to_array_deprecated();
27970 }
27971 } while (0);
27972
27973 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27974 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27975 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27976 }
27977
ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27978 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27979 {
27980 USE_OPLINE
27981 zval *container;
27982 zval *offset;
27983 zend_string *name, *tmp_name;
27984
27985 SAVE_OPLINE();
27986 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27987 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27988
27989 do {
27990 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
27991 if (Z_ISREF_P(container)) {
27992 container = Z_REFVAL_P(container);
27993 if (Z_TYPE_P(container) != IS_OBJECT) {
27994 if (IS_VAR == IS_CV
27995 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
27996 ZVAL_UNDEFINED_OP1();
27997 }
27998 break;
27999 }
28000 } else {
28001 break;
28002 }
28003 }
28004 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28005 name = Z_STR_P(offset);
28006 } else {
28007 name = zval_try_get_tmp_string(offset, &tmp_name);
28008 if (UNEXPECTED(!name)) {
28009 break;
28010 }
28011 }
28012 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));
28013 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28014 zend_tmp_string_release(tmp_name);
28015 }
28016 } while (0);
28017
28018 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28019 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28020 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28021 }
28022
ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28023 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28024 {
28025 USE_OPLINE
28026
28027 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
28028
28029 SAVE_OPLINE();
28030 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
28031 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28032 }
28033
28034 /* Destroy the previously yielded value */
28035 zval_ptr_dtor(&generator->value);
28036
28037 /* Destroy the previously yielded key */
28038 zval_ptr_dtor(&generator->key);
28039
28040 /* Set the new yielded value */
28041 if (IS_VAR != IS_UNUSED) {
28042 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
28043 /* Constants and temporary variables aren't yieldable by reference,
28044 * but we still allow them with a notice. */
28045 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
28046 zval *value;
28047
28048 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28049
28050 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28051 ZVAL_COPY_VALUE(&generator->value, value);
28052 if (IS_VAR == IS_CONST) {
28053 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28054 Z_ADDREF(generator->value);
28055 }
28056 }
28057 } else {
28058 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28059
28060 /* If a function call result is yielded and the function did
28061 * not return by reference we throw a notice. */
28062 do {
28063 if (IS_VAR == IS_VAR) {
28064 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
28065 if (opline->extended_value == ZEND_RETURNS_FUNCTION
28066 && !Z_ISREF_P(value_ptr)) {
28067 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28068 ZVAL_COPY(&generator->value, value_ptr);
28069 break;
28070 }
28071 }
28072 if (Z_ISREF_P(value_ptr)) {
28073 Z_ADDREF_P(value_ptr);
28074 } else {
28075 ZVAL_MAKE_REF_EX(value_ptr, 2);
28076 }
28077 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
28078 } while (0);
28079
28080 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28081 }
28082 } else {
28083 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28084
28085 /* Consts, temporary variables and references need copying */
28086 if (IS_VAR == IS_CONST) {
28087 ZVAL_COPY_VALUE(&generator->value, value);
28088 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28089 Z_ADDREF(generator->value);
28090 }
28091 } else if (IS_VAR == IS_TMP_VAR) {
28092 ZVAL_COPY_VALUE(&generator->value, value);
28093 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
28094 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
28095 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28096 } else {
28097 ZVAL_COPY_VALUE(&generator->value, value);
28098 if (IS_VAR == IS_CV) {
28099 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
28100 }
28101 }
28102 }
28103 } else {
28104 /* If no value was specified yield null */
28105 ZVAL_NULL(&generator->value);
28106 }
28107
28108 /* Set the new yielded key */
28109 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28110 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28111 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
28112 key = Z_REFVAL_P(key);
28113 }
28114 ZVAL_COPY(&generator->key, key);
28115 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28116
28117 if (Z_TYPE(generator->key) == IS_LONG
28118 && Z_LVAL(generator->key) > generator->largest_used_integer_key
28119 ) {
28120 generator->largest_used_integer_key = Z_LVAL(generator->key);
28121 }
28122 } else {
28123 /* If no key was specified we use auto-increment keys */
28124 generator->largest_used_integer_key++;
28125 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
28126 }
28127
28128 if (RETURN_VALUE_USED(opline)) {
28129 /* If the return value of yield is used set the send
28130 * target and initialize it to NULL */
28131 generator->send_target = EX_VAR(opline->result.var);
28132 ZVAL_NULL(generator->send_target);
28133 } else {
28134 generator->send_target = NULL;
28135 }
28136
28137 /* We increment to the next op, so we are at the correct position when the
28138 * generator is resumed. */
28139 ZEND_VM_INC_OPCODE();
28140
28141 /* The GOTO VM uses a local opline variable. We need to set the opline
28142 * variable in execute_data so we don't resume at an old position. */
28143 SAVE_OPLINE();
28144
28145 ZEND_VM_RETURN();
28146 }
28147
ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28148 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28149 {
28150 USE_OPLINE
28151 zval *op1, *op2;
28152 bool result;
28153
28154 SAVE_OPLINE();
28155 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28156 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28157 result = fast_is_identical_function(op1, op2);
28158 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28159 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28160 ZEND_VM_SMART_BRANCH(result, 1);
28161 }
28162
ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28163 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28164 {
28165 USE_OPLINE
28166 zval *op1, *op2;
28167 bool result;
28168
28169 SAVE_OPLINE();
28170 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28171 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28172 result = fast_is_identical_function(op1, op2);
28173 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28174 ZEND_VM_SMART_BRANCH(result, 1);
28175 }
28176
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28177 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28178 {
28179 USE_OPLINE
28180 zval *op1, *op2;
28181 bool result;
28182
28183 SAVE_OPLINE();
28184 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28185 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28186 result = fast_is_not_identical_function(op1, op2);
28187 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28188 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28189 ZEND_VM_SMART_BRANCH(result, 1);
28190 }
28191
ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28192 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28193 {
28194 USE_OPLINE
28195 zval *value;
28196 zval *variable_ptr;
28197
28198 SAVE_OPLINE();
28199 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28200 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28201
28202 if (0 || UNEXPECTED(0)) {
28203 zend_refcounted *garbage = NULL;
28204
28205 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28206 if (UNEXPECTED(0)) {
28207 ZVAL_COPY(EX_VAR(opline->result.var), value);
28208 }
28209 if (garbage) {
28210 GC_DTOR_NO_REF(garbage);
28211 }
28212 } else {
28213 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
28214 }
28215 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28216 /* zend_assign_to_variable() always takes care of op2, never free it! */
28217
28218 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28219 }
28220
ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28221 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28222 {
28223 USE_OPLINE
28224 zval *value;
28225 zval *variable_ptr;
28226
28227 SAVE_OPLINE();
28228 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28229 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28230
28231 if (0 || UNEXPECTED(1)) {
28232 zend_refcounted *garbage = NULL;
28233
28234 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28235 if (UNEXPECTED(1)) {
28236 ZVAL_COPY(EX_VAR(opline->result.var), value);
28237 }
28238 if (garbage) {
28239 GC_DTOR_NO_REF(garbage);
28240 }
28241 } else {
28242 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
28243 }
28244 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28245 /* zend_assign_to_variable() always takes care of op2, never free it! */
28246
28247 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28248 }
28249
ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28250 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28251 {
28252 USE_OPLINE
28253 zval *op1, *op2;
28254 bool result;
28255
28256 SAVE_OPLINE();
28257 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28258 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28259 result = fast_is_identical_function(op1, op2);
28260 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28261 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28262 ZEND_VM_SMART_BRANCH(result, 1);
28263 }
28264
ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28265 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28266 {
28267 USE_OPLINE
28268 zval *op1, *op2;
28269 bool result;
28270
28271 SAVE_OPLINE();
28272 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28273 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28274 result = fast_is_identical_function(op1, op2);
28275 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28276 ZEND_VM_SMART_BRANCH(result, 1);
28277 }
28278
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28279 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28280 {
28281 USE_OPLINE
28282 zval *op1, *op2;
28283 bool result;
28284
28285 SAVE_OPLINE();
28286 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28287 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28288 result = fast_is_not_identical_function(op1, op2);
28289 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28290 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28291 ZEND_VM_SMART_BRANCH(result, 1);
28292 }
28293
ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28294 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28295 {
28296 USE_OPLINE
28297 zval *value;
28298 zval *variable_ptr;
28299
28300 SAVE_OPLINE();
28301 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28302 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28303
28304 if (0 || UNEXPECTED(0)) {
28305 zend_refcounted *garbage = NULL;
28306
28307 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28308 if (UNEXPECTED(0)) {
28309 ZVAL_COPY(EX_VAR(opline->result.var), value);
28310 }
28311 if (garbage) {
28312 GC_DTOR_NO_REF(garbage);
28313 }
28314 } else {
28315 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
28316 }
28317 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28318 /* zend_assign_to_variable() always takes care of op2, never free it! */
28319
28320 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28321 }
28322
ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28323 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28324 {
28325 USE_OPLINE
28326 zval *value;
28327 zval *variable_ptr;
28328
28329 SAVE_OPLINE();
28330 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28331 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28332
28333 if (0 || UNEXPECTED(1)) {
28334 zend_refcounted *garbage = NULL;
28335
28336 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28337 if (UNEXPECTED(1)) {
28338 ZVAL_COPY(EX_VAR(opline->result.var), value);
28339 }
28340 if (garbage) {
28341 GC_DTOR_NO_REF(garbage);
28342 }
28343 } else {
28344 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
28345 }
28346 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28347 /* zend_assign_to_variable() always takes care of op2, never free it! */
28348
28349 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28350 }
28351
ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28352 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28353 {
28354 USE_OPLINE
28355 zval *variable_ptr;
28356 zval *value_ptr;
28357 zend_refcounted *garbage = NULL;
28358
28359 SAVE_OPLINE();
28360 value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28361 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28362
28363 if (IS_VAR == IS_VAR &&
28364 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
28365
28366 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
28367 variable_ptr = &EG(uninitialized_zval);
28368 } else if (IS_VAR == IS_VAR &&
28369 opline->extended_value == ZEND_RETURNS_FUNCTION &&
28370 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
28371
28372 variable_ptr = zend_wrong_assign_to_variable_reference(
28373 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
28374 } else {
28375 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
28376 }
28377
28378 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28379 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
28380 }
28381
28382 if (garbage) {
28383 GC_DTOR(garbage);
28384 }
28385
28386 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28387 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28388 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28389 }
28390
ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28391 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28392 {
28393 USE_OPLINE
28394 zval *var_ptr;
28395 zval *value, *container, *dim;
28396 HashTable *ht;
28397
28398 SAVE_OPLINE();
28399 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28400
28401 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28402 assign_dim_op_array:
28403 SEPARATE_ARRAY(container);
28404 ht = Z_ARRVAL_P(container);
28405 assign_dim_op_new_array:
28406 dim = NULL;
28407 if (IS_UNUSED == IS_UNUSED) {
28408 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
28409 if (UNEXPECTED(!var_ptr)) {
28410 zend_cannot_add_element();
28411 goto assign_dim_op_ret_null;
28412 }
28413 } else {
28414 if (IS_UNUSED == IS_CONST) {
28415 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
28416 } else {
28417 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
28418 }
28419 if (UNEXPECTED(!var_ptr)) {
28420 goto assign_dim_op_ret_null;
28421 }
28422 }
28423
28424 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
28425
28426 do {
28427 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
28428 zend_reference *ref = Z_REF_P(var_ptr);
28429 var_ptr = Z_REFVAL_P(var_ptr);
28430 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
28431 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
28432 break;
28433 }
28434 }
28435 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
28436 } while (0);
28437
28438 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28439 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
28440 }
28441 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
28442 } else {
28443 if (EXPECTED(Z_ISREF_P(container))) {
28444 container = Z_REFVAL_P(container);
28445 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28446 goto assign_dim_op_array;
28447 }
28448 }
28449
28450 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
28451 zend_object *obj = Z_OBJ_P(container);
28452
28453 dim = NULL;
28454 if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28455 dim++;
28456 }
28457 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
28458 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
28459 uint8_t old_type;
28460
28461 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
28462 ZVAL_UNDEFINED_OP1();
28463 }
28464 ht = zend_new_array(8);
28465 old_type = Z_TYPE_P(container);
28466 ZVAL_ARR(container, ht);
28467 if (UNEXPECTED(old_type == IS_FALSE)) {
28468 GC_ADDREF(ht);
28469 zend_false_to_array_deprecated();
28470 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28471 zend_array_destroy(ht);
28472 goto assign_dim_op_ret_null;
28473 }
28474 }
28475 goto assign_dim_op_new_array;
28476 } else {
28477 dim = NULL;
28478 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
28479 assign_dim_op_ret_null:
28480 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
28481 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28482 ZVAL_NULL(EX_VAR(opline->result.var));
28483 }
28484 }
28485 }
28486
28487 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28488 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28489 }
28490
ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28491 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28492 {
28493 USE_OPLINE
28494 zval *container;
28495
28496 SAVE_OPLINE();
28497 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28498 zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
28499
28500 if (IS_VAR == IS_VAR) {
28501 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
28502 }
28503 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28504 }
28505
ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28506 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28507 {
28508 USE_OPLINE
28509 zval *container;
28510
28511 SAVE_OPLINE();
28512 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28513 zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
28514
28515 if (IS_VAR == IS_VAR) {
28516 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
28517 }
28518 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28519 }
28520
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28521 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28522 {
28523 #if 0
28524 USE_OPLINE
28525 #endif
28526
28527 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
28528 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
28529 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28530 }
28531 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28532 } else {
28533 if (IS_UNUSED == IS_UNUSED) {
28534 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28535 }
28536 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28537 }
28538 }
28539
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28540 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28541 {
28542 USE_OPLINE
28543 zval *object_ptr, *orig_object_ptr;
28544 zval *value;
28545 zval *variable_ptr;
28546 zval *dim;
28547 zend_refcounted *garbage = NULL;
28548
28549 SAVE_OPLINE();
28550 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28551
28552 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28553 try_assign_dim_array:
28554 SEPARATE_ARRAY(object_ptr);
28555 if (IS_UNUSED == IS_UNUSED) {
28556 value = RT_CONSTANT((opline+1), (opline+1)->op1);
28557 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28558 HashTable *ht = Z_ARRVAL_P(object_ptr);
28559 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28560 GC_ADDREF(ht);
28561 }
28562 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28563 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28564 zend_array_destroy(ht);
28565 goto assign_dim_error;
28566 }
28567 }
28568 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
28569 ZVAL_DEREF(value);
28570 }
28571 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28572 if (UNEXPECTED(value == NULL)) {
28573 zend_cannot_add_element();
28574 goto assign_dim_error;
28575 } else if (IS_CONST == IS_CV) {
28576 if (Z_REFCOUNTED_P(value)) {
28577 Z_ADDREF_P(value);
28578 }
28579 } else if (IS_CONST == IS_VAR) {
28580 zval *free_op_data = EX_VAR((opline+1)->op1.var);
28581 if (Z_ISREF_P(free_op_data)) {
28582 if (Z_REFCOUNTED_P(value)) {
28583 Z_ADDREF_P(value);
28584 }
28585 zval_ptr_dtor_nogc(free_op_data);
28586 }
28587 } else if (IS_CONST == IS_CONST) {
28588 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28589 Z_ADDREF_P(value);
28590 }
28591 }
28592 } else {
28593 dim = NULL;
28594 if (IS_UNUSED == IS_CONST) {
28595 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28596 } else {
28597 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28598 }
28599 if (UNEXPECTED(variable_ptr == NULL)) {
28600 goto assign_dim_error;
28601 }
28602 value = RT_CONSTANT((opline+1), (opline+1)->op1);
28603 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
28604 }
28605 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28606 ZVAL_COPY(EX_VAR(opline->result.var), value);
28607 }
28608 if (garbage) {
28609 GC_DTOR_NO_REF(garbage);
28610 }
28611 } else {
28612 if (EXPECTED(Z_ISREF_P(object_ptr))) {
28613 object_ptr = Z_REFVAL_P(object_ptr);
28614 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28615 goto try_assign_dim_array;
28616 }
28617 }
28618 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28619 zend_object *obj = Z_OBJ_P(object_ptr);
28620
28621 GC_ADDREF(obj);
28622 dim = NULL;
28623 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28624 dim = ZVAL_UNDEFINED_OP2();
28625 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28626 dim++;
28627 }
28628
28629 value = RT_CONSTANT((opline+1), (opline+1)->op1);
28630 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28631 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28632 } else if (IS_CONST & (IS_CV|IS_VAR)) {
28633 ZVAL_DEREF(value);
28634 }
28635
28636 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28637
28638 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28639 zend_objects_store_del(obj);
28640 }
28641 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28642 if (IS_UNUSED == IS_UNUSED) {
28643 zend_use_new_element_for_string();
28644
28645 UNDEF_RESULT();
28646 } else {
28647 dim = NULL;
28648 value = RT_CONSTANT((opline+1), (opline+1)->op1);
28649 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28650
28651 }
28652 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28653 if (Z_ISREF_P(orig_object_ptr)
28654 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28655 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28656 dim = NULL;
28657
28658 UNDEF_RESULT();
28659 } else {
28660 HashTable *ht = zend_new_array(8);
28661 uint8_t old_type = Z_TYPE_P(object_ptr);
28662
28663 ZVAL_ARR(object_ptr, ht);
28664 if (UNEXPECTED(old_type == IS_FALSE)) {
28665 GC_ADDREF(ht);
28666 zend_false_to_array_deprecated();
28667 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28668 zend_array_destroy(ht);
28669 goto assign_dim_error;
28670 }
28671 }
28672 goto try_assign_dim_array;
28673 }
28674 } else {
28675 zend_use_scalar_as_array();
28676 dim = NULL;
28677 assign_dim_error:
28678
28679 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28680 ZVAL_NULL(EX_VAR(opline->result.var));
28681 }
28682 }
28683 }
28684 if (IS_UNUSED != IS_UNUSED) {
28685
28686 }
28687 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28688 /* assign_dim has two opcodes! */
28689 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28690 }
28691
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28692 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28693 {
28694 USE_OPLINE
28695 zval *object_ptr, *orig_object_ptr;
28696 zval *value;
28697 zval *variable_ptr;
28698 zval *dim;
28699 zend_refcounted *garbage = NULL;
28700
28701 SAVE_OPLINE();
28702 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28703
28704 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28705 try_assign_dim_array:
28706 SEPARATE_ARRAY(object_ptr);
28707 if (IS_UNUSED == IS_UNUSED) {
28708 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
28709 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28710 HashTable *ht = Z_ARRVAL_P(object_ptr);
28711 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28712 GC_ADDREF(ht);
28713 }
28714 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28715 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28716 zend_array_destroy(ht);
28717 goto assign_dim_error;
28718 }
28719 }
28720 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
28721 ZVAL_DEREF(value);
28722 }
28723 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28724 if (UNEXPECTED(value == NULL)) {
28725 zend_cannot_add_element();
28726 goto assign_dim_error;
28727 } else if (IS_TMP_VAR == IS_CV) {
28728 if (Z_REFCOUNTED_P(value)) {
28729 Z_ADDREF_P(value);
28730 }
28731 } else if (IS_TMP_VAR == IS_VAR) {
28732 zval *free_op_data = EX_VAR((opline+1)->op1.var);
28733 if (Z_ISREF_P(free_op_data)) {
28734 if (Z_REFCOUNTED_P(value)) {
28735 Z_ADDREF_P(value);
28736 }
28737 zval_ptr_dtor_nogc(free_op_data);
28738 }
28739 } else if (IS_TMP_VAR == IS_CONST) {
28740 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28741 Z_ADDREF_P(value);
28742 }
28743 }
28744 } else {
28745 dim = NULL;
28746 if (IS_UNUSED == IS_CONST) {
28747 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28748 } else {
28749 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28750 }
28751 if (UNEXPECTED(variable_ptr == NULL)) {
28752 goto assign_dim_error;
28753 }
28754 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
28755 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28756 }
28757 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28758 ZVAL_COPY(EX_VAR(opline->result.var), value);
28759 }
28760 if (garbage) {
28761 GC_DTOR_NO_REF(garbage);
28762 }
28763 } else {
28764 if (EXPECTED(Z_ISREF_P(object_ptr))) {
28765 object_ptr = Z_REFVAL_P(object_ptr);
28766 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28767 goto try_assign_dim_array;
28768 }
28769 }
28770 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28771 zend_object *obj = Z_OBJ_P(object_ptr);
28772
28773 GC_ADDREF(obj);
28774 dim = NULL;
28775 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28776 dim = ZVAL_UNDEFINED_OP2();
28777 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28778 dim++;
28779 }
28780
28781 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
28782 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28783 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28784 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
28785 ZVAL_DEREF(value);
28786 }
28787
28788 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28789
28790 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28791 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28792 zend_objects_store_del(obj);
28793 }
28794 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28795 if (IS_UNUSED == IS_UNUSED) {
28796 zend_use_new_element_for_string();
28797 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28798 UNDEF_RESULT();
28799 } else {
28800 dim = NULL;
28801 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
28802 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28803 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28804 }
28805 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28806 if (Z_ISREF_P(orig_object_ptr)
28807 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28808 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28809 dim = NULL;
28810 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28811 UNDEF_RESULT();
28812 } else {
28813 HashTable *ht = zend_new_array(8);
28814 uint8_t old_type = Z_TYPE_P(object_ptr);
28815
28816 ZVAL_ARR(object_ptr, ht);
28817 if (UNEXPECTED(old_type == IS_FALSE)) {
28818 GC_ADDREF(ht);
28819 zend_false_to_array_deprecated();
28820 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28821 zend_array_destroy(ht);
28822 goto assign_dim_error;
28823 }
28824 }
28825 goto try_assign_dim_array;
28826 }
28827 } else {
28828 zend_use_scalar_as_array();
28829 dim = NULL;
28830 assign_dim_error:
28831 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28832 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28833 ZVAL_NULL(EX_VAR(opline->result.var));
28834 }
28835 }
28836 }
28837 if (IS_UNUSED != IS_UNUSED) {
28838
28839 }
28840 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28841 /* assign_dim has two opcodes! */
28842 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28843 }
28844
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28845 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28846 {
28847 USE_OPLINE
28848 zval *object_ptr, *orig_object_ptr;
28849 zval *value;
28850 zval *variable_ptr;
28851 zval *dim;
28852 zend_refcounted *garbage = NULL;
28853
28854 SAVE_OPLINE();
28855 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28856
28857 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28858 try_assign_dim_array:
28859 SEPARATE_ARRAY(object_ptr);
28860 if (IS_UNUSED == IS_UNUSED) {
28861 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28862 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28863 HashTable *ht = Z_ARRVAL_P(object_ptr);
28864 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28865 GC_ADDREF(ht);
28866 }
28867 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28868 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28869 zend_array_destroy(ht);
28870 goto assign_dim_error;
28871 }
28872 }
28873 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
28874 ZVAL_DEREF(value);
28875 }
28876 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28877 if (UNEXPECTED(value == NULL)) {
28878 zend_cannot_add_element();
28879 goto assign_dim_error;
28880 } else if (IS_VAR == IS_CV) {
28881 if (Z_REFCOUNTED_P(value)) {
28882 Z_ADDREF_P(value);
28883 }
28884 } else if (IS_VAR == IS_VAR) {
28885 zval *free_op_data = EX_VAR((opline+1)->op1.var);
28886 if (Z_ISREF_P(free_op_data)) {
28887 if (Z_REFCOUNTED_P(value)) {
28888 Z_ADDREF_P(value);
28889 }
28890 zval_ptr_dtor_nogc(free_op_data);
28891 }
28892 } else if (IS_VAR == IS_CONST) {
28893 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28894 Z_ADDREF_P(value);
28895 }
28896 }
28897 } else {
28898 dim = NULL;
28899 if (IS_UNUSED == IS_CONST) {
28900 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28901 } else {
28902 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28903 }
28904 if (UNEXPECTED(variable_ptr == NULL)) {
28905 goto assign_dim_error;
28906 }
28907 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28908 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28909 }
28910 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28911 ZVAL_COPY(EX_VAR(opline->result.var), value);
28912 }
28913 if (garbage) {
28914 GC_DTOR_NO_REF(garbage);
28915 }
28916 } else {
28917 if (EXPECTED(Z_ISREF_P(object_ptr))) {
28918 object_ptr = Z_REFVAL_P(object_ptr);
28919 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28920 goto try_assign_dim_array;
28921 }
28922 }
28923 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28924 zend_object *obj = Z_OBJ_P(object_ptr);
28925
28926 GC_ADDREF(obj);
28927 dim = NULL;
28928 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28929 dim = ZVAL_UNDEFINED_OP2();
28930 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28931 dim++;
28932 }
28933
28934 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28935 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28936 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28937 } else if (IS_VAR & (IS_CV|IS_VAR)) {
28938 ZVAL_DEREF(value);
28939 }
28940
28941 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28942
28943 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28944 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28945 zend_objects_store_del(obj);
28946 }
28947 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28948 if (IS_UNUSED == IS_UNUSED) {
28949 zend_use_new_element_for_string();
28950 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28951 UNDEF_RESULT();
28952 } else {
28953 dim = NULL;
28954 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28955 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28956 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28957 }
28958 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28959 if (Z_ISREF_P(orig_object_ptr)
28960 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28961 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28962 dim = NULL;
28963 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28964 UNDEF_RESULT();
28965 } else {
28966 HashTable *ht = zend_new_array(8);
28967 uint8_t old_type = Z_TYPE_P(object_ptr);
28968
28969 ZVAL_ARR(object_ptr, ht);
28970 if (UNEXPECTED(old_type == IS_FALSE)) {
28971 GC_ADDREF(ht);
28972 zend_false_to_array_deprecated();
28973 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28974 zend_array_destroy(ht);
28975 goto assign_dim_error;
28976 }
28977 }
28978 goto try_assign_dim_array;
28979 }
28980 } else {
28981 zend_use_scalar_as_array();
28982 dim = NULL;
28983 assign_dim_error:
28984 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28985 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28986 ZVAL_NULL(EX_VAR(opline->result.var));
28987 }
28988 }
28989 }
28990 if (IS_UNUSED != IS_UNUSED) {
28991
28992 }
28993 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28994 /* assign_dim has two opcodes! */
28995 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28996 }
28997
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28998 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28999 {
29000 USE_OPLINE
29001 zval *object_ptr, *orig_object_ptr;
29002 zval *value;
29003 zval *variable_ptr;
29004 zval *dim;
29005 zend_refcounted *garbage = NULL;
29006
29007 SAVE_OPLINE();
29008 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29009
29010 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29011 try_assign_dim_array:
29012 SEPARATE_ARRAY(object_ptr);
29013 if (IS_UNUSED == IS_UNUSED) {
29014 value = EX_VAR((opline+1)->op1.var);
29015 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29016 HashTable *ht = Z_ARRVAL_P(object_ptr);
29017 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29018 GC_ADDREF(ht);
29019 }
29020 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29021 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29022 zend_array_destroy(ht);
29023 goto assign_dim_error;
29024 }
29025 }
29026 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
29027 ZVAL_DEREF(value);
29028 }
29029 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29030 if (UNEXPECTED(value == NULL)) {
29031 zend_cannot_add_element();
29032 goto assign_dim_error;
29033 } else if (IS_CV == IS_CV) {
29034 if (Z_REFCOUNTED_P(value)) {
29035 Z_ADDREF_P(value);
29036 }
29037 } else if (IS_CV == IS_VAR) {
29038 zval *free_op_data = EX_VAR((opline+1)->op1.var);
29039 if (Z_ISREF_P(free_op_data)) {
29040 if (Z_REFCOUNTED_P(value)) {
29041 Z_ADDREF_P(value);
29042 }
29043 zval_ptr_dtor_nogc(free_op_data);
29044 }
29045 } else if (IS_CV == IS_CONST) {
29046 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29047 Z_ADDREF_P(value);
29048 }
29049 }
29050 } else {
29051 dim = NULL;
29052 if (IS_UNUSED == IS_CONST) {
29053 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29054 } else {
29055 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29056 }
29057 if (UNEXPECTED(variable_ptr == NULL)) {
29058 goto assign_dim_error;
29059 }
29060 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
29061 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
29062 }
29063 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29064 ZVAL_COPY(EX_VAR(opline->result.var), value);
29065 }
29066 if (garbage) {
29067 GC_DTOR_NO_REF(garbage);
29068 }
29069 } else {
29070 if (EXPECTED(Z_ISREF_P(object_ptr))) {
29071 object_ptr = Z_REFVAL_P(object_ptr);
29072 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29073 goto try_assign_dim_array;
29074 }
29075 }
29076 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29077 zend_object *obj = Z_OBJ_P(object_ptr);
29078
29079 GC_ADDREF(obj);
29080 dim = NULL;
29081 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29082 dim = ZVAL_UNDEFINED_OP2();
29083 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29084 dim++;
29085 }
29086
29087 value = EX_VAR((opline+1)->op1.var);
29088 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29089 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29090 } else if (IS_CV & (IS_CV|IS_VAR)) {
29091 ZVAL_DEREF(value);
29092 }
29093
29094 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29095
29096 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29097 zend_objects_store_del(obj);
29098 }
29099 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29100 if (IS_UNUSED == IS_UNUSED) {
29101 zend_use_new_element_for_string();
29102
29103 UNDEF_RESULT();
29104 } else {
29105 dim = NULL;
29106 value = EX_VAR((opline+1)->op1.var);
29107 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29108
29109 }
29110 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29111 if (Z_ISREF_P(orig_object_ptr)
29112 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29113 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29114 dim = NULL;
29115
29116 UNDEF_RESULT();
29117 } else {
29118 HashTable *ht = zend_new_array(8);
29119 uint8_t old_type = Z_TYPE_P(object_ptr);
29120
29121 ZVAL_ARR(object_ptr, ht);
29122 if (UNEXPECTED(old_type == IS_FALSE)) {
29123 GC_ADDREF(ht);
29124 zend_false_to_array_deprecated();
29125 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29126 zend_array_destroy(ht);
29127 goto assign_dim_error;
29128 }
29129 }
29130 goto try_assign_dim_array;
29131 }
29132 } else {
29133 zend_use_scalar_as_array();
29134 dim = NULL;
29135 assign_dim_error:
29136
29137 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29138 ZVAL_NULL(EX_VAR(opline->result.var));
29139 }
29140 }
29141 }
29142 if (IS_UNUSED != IS_UNUSED) {
29143
29144 }
29145 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29146 /* assign_dim has two opcodes! */
29147 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29148 }
29149
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29150 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29151 {
29152 USE_OPLINE
29153 zval *function_name;
29154 zend_class_entry *ce;
29155 uint32_t call_info;
29156 zend_function *fbc;
29157 zend_execute_data *call;
29158
29159 SAVE_OPLINE();
29160
29161 if (IS_VAR == IS_CONST) {
29162 /* no function found. try a static method in class */
29163 ce = CACHED_PTR(opline->result.num);
29164 if (UNEXPECTED(ce == NULL)) {
29165 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);
29166 if (UNEXPECTED(ce == NULL)) {
29167
29168 HANDLE_EXCEPTION();
29169 }
29170 if (IS_UNUSED != IS_CONST) {
29171 CACHE_PTR(opline->result.num, ce);
29172 }
29173 }
29174 } else if (IS_VAR == IS_UNUSED) {
29175 ce = zend_fetch_class(NULL, opline->op1.num);
29176 if (UNEXPECTED(ce == NULL)) {
29177
29178 HANDLE_EXCEPTION();
29179 }
29180 } else {
29181 ce = Z_CE_P(EX_VAR(opline->op1.var));
29182 }
29183
29184 if (IS_VAR == IS_CONST &&
29185 IS_UNUSED == IS_CONST &&
29186 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
29187 /* nothing to do */
29188 } else if (IS_VAR != IS_CONST &&
29189 IS_UNUSED == IS_CONST &&
29190 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
29191 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
29192 } else if (IS_UNUSED != IS_UNUSED) {
29193 function_name = NULL;
29194 if (IS_UNUSED != IS_CONST) {
29195 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
29196 do {
29197 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
29198 function_name = Z_REFVAL_P(function_name);
29199 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
29200 break;
29201 }
29202 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
29203 ZVAL_UNDEFINED_OP2();
29204 if (UNEXPECTED(EG(exception) != NULL)) {
29205 HANDLE_EXCEPTION();
29206 }
29207 }
29208 zend_throw_error(NULL, "Method name must be a string");
29209
29210 HANDLE_EXCEPTION();
29211 } while (0);
29212 }
29213 }
29214
29215 if (ce->get_static_method) {
29216 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
29217 } else {
29218 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
29219 }
29220 if (UNEXPECTED(fbc == NULL)) {
29221 if (EXPECTED(!EG(exception))) {
29222 zend_undefined_method(ce, Z_STR_P(function_name));
29223 }
29224
29225 HANDLE_EXCEPTION();
29226 }
29227 if (IS_UNUSED == IS_CONST &&
29228 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
29229 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
29230 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
29231 }
29232 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
29233 init_func_run_time_cache(&fbc->op_array);
29234 }
29235 if (IS_UNUSED != IS_CONST) {
29236
29237 }
29238 } else {
29239 if (UNEXPECTED(ce->constructor == NULL)) {
29240 zend_throw_error(NULL, "Cannot call constructor");
29241 HANDLE_EXCEPTION();
29242 }
29243 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
29244 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
29245 HANDLE_EXCEPTION();
29246 }
29247 fbc = ce->constructor;
29248 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
29249 init_func_run_time_cache(&fbc->op_array);
29250 }
29251 }
29252
29253 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
29254 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
29255 ce = (zend_class_entry*)Z_OBJ(EX(This));
29256 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
29257 } else {
29258 zend_non_static_method_call(fbc);
29259 HANDLE_EXCEPTION();
29260 }
29261 } else {
29262 /* previous opcode is ZEND_FETCH_CLASS */
29263 if (IS_VAR == IS_UNUSED
29264 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
29265 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
29266 if (Z_TYPE(EX(This)) == IS_OBJECT) {
29267 ce = Z_OBJCE(EX(This));
29268 } else {
29269 ce = Z_CE(EX(This));
29270 }
29271 }
29272 call_info = ZEND_CALL_NESTED_FUNCTION;
29273 }
29274
29275 call = zend_vm_stack_push_call_frame(call_info,
29276 fbc, opline->extended_value, ce);
29277 call->prev_execute_data = EX(call);
29278 EX(call) = call;
29279
29280 ZEND_VM_NEXT_OPCODE();
29281 }
29282
ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29283 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29284 {
29285 if (IS_VAR == IS_UNUSED) {
29286 SAVE_OPLINE();
29287 zend_verify_missing_return_type(EX(func));
29288 HANDLE_EXCEPTION();
29289 } else {
29290 /* prevents "undefined variable opline" errors */
29291 #if 0 || (IS_VAR != IS_UNUSED)
29292 USE_OPLINE
29293 zval *retval_ref, *retval_ptr;
29294 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
29295 retval_ref = retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29296
29297 if (IS_VAR == IS_CONST) {
29298 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
29299 retval_ref = retval_ptr = EX_VAR(opline->result.var);
29300 } else if (IS_VAR == IS_VAR) {
29301 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
29302 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
29303 }
29304 ZVAL_DEREF(retval_ptr);
29305 } else if (IS_VAR == IS_CV) {
29306 ZVAL_DEREF(retval_ptr);
29307 }
29308
29309 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
29310 ZEND_VM_NEXT_OPCODE();
29311 }
29312
29313 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
29314 SAVE_OPLINE();
29315 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
29316 if (UNEXPECTED(EG(exception))) {
29317 HANDLE_EXCEPTION();
29318 }
29319 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
29320 ZEND_VM_NEXT_OPCODE();
29321 }
29322 }
29323
29324 zend_reference *ref = NULL;
29325 void *cache_slot = CACHE_ADDR(opline->op2.num);
29326 if (UNEXPECTED(retval_ref != retval_ptr)) {
29327 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
29328 ref = Z_REF_P(retval_ref);
29329 } else {
29330 /* A cast might happen - unwrap the reference if this is a by-value return */
29331 if (Z_REFCOUNT_P(retval_ref) == 1) {
29332 ZVAL_UNREF(retval_ref);
29333 } else {
29334 Z_DELREF_P(retval_ref);
29335 ZVAL_COPY(retval_ref, retval_ptr);
29336 }
29337 retval_ptr = retval_ref;
29338 }
29339 }
29340
29341 SAVE_OPLINE();
29342 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
29343 zend_verify_return_error(EX(func), retval_ptr);
29344 HANDLE_EXCEPTION();
29345 }
29346 ZEND_VM_NEXT_OPCODE();
29347 #endif
29348 }
29349 }
29350
ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29351 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29352 {
29353 USE_OPLINE
29354 zval *varptr, *arg;
29355
29356 if (IS_UNUSED == IS_CONST) {
29357 SAVE_OPLINE();
29358 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29359 uint32_t arg_num;
29360 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29361 if (UNEXPECTED(!arg)) {
29362 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29363 HANDLE_EXCEPTION();
29364 }
29365 } else {
29366 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29367 }
29368
29369 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29370 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
29371 SAVE_OPLINE();
29372 ZVAL_UNDEFINED_OP1();
29373 ZVAL_NULL(arg);
29374 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29375 }
29376
29377 if (IS_VAR == IS_CV) {
29378 ZVAL_COPY_DEREF(arg, varptr);
29379 } else /* if (IS_VAR == IS_VAR) */ {
29380 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29381 zend_refcounted *ref = Z_COUNTED_P(varptr);
29382
29383 varptr = Z_REFVAL_P(varptr);
29384 ZVAL_COPY_VALUE(arg, varptr);
29385 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29386 efree_size(ref, sizeof(zend_reference));
29387 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29388 Z_ADDREF_P(arg);
29389 }
29390 } else {
29391 ZVAL_COPY_VALUE(arg, varptr);
29392 }
29393 }
29394
29395 ZEND_VM_NEXT_OPCODE();
29396 }
29397
ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29398 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29399 {
29400 USE_OPLINE
29401 zval *varptr, *arg;
29402
29403 if (IS_UNUSED == IS_CONST) {
29404 SAVE_OPLINE();
29405 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29406 uint32_t arg_num;
29407 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29408 if (UNEXPECTED(!arg)) {
29409 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29410 HANDLE_EXCEPTION();
29411 }
29412 } else {
29413 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29414 }
29415
29416 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29417 ZVAL_COPY_VALUE(arg, varptr);
29418
29419 if (EXPECTED(Z_ISREF_P(varptr))) {
29420 ZEND_VM_NEXT_OPCODE();
29421 }
29422
29423 SAVE_OPLINE();
29424 ZVAL_NEW_REF(arg, arg);
29425 zend_error(E_NOTICE, "Only variables should be passed by reference");
29426 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29427 }
29428
ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29429 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29430 {
29431 USE_OPLINE
29432 zval *varptr, *arg;
29433 uint32_t arg_num;
29434
29435 if (IS_UNUSED == IS_CONST) {
29436 SAVE_OPLINE();
29437 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29438 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29439 if (UNEXPECTED(!arg)) {
29440 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29441 HANDLE_EXCEPTION();
29442 }
29443 } else {
29444 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29445 arg_num = opline->op2.num;
29446 }
29447
29448 if (EXPECTED(0)) {
29449 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29450 goto send_var;
29451 }
29452
29453 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29454 ZVAL_COPY_VALUE(arg, varptr);
29455
29456 if (EXPECTED(Z_ISREF_P(varptr) ||
29457 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
29458 ZEND_VM_NEXT_OPCODE();
29459 }
29460 } else {
29461 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29462 goto send_var;
29463 }
29464
29465 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29466 ZVAL_COPY_VALUE(arg, varptr);
29467
29468 if (EXPECTED(Z_ISREF_P(varptr) ||
29469 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
29470 ZEND_VM_NEXT_OPCODE();
29471 }
29472 }
29473
29474 SAVE_OPLINE();
29475 ZVAL_NEW_REF(arg, arg);
29476 zend_error(E_NOTICE, "Only variables should be passed by reference");
29477 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29478
29479 send_var:
29480 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29481 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29482 zend_refcounted *ref = Z_COUNTED_P(varptr);
29483
29484 varptr = Z_REFVAL_P(varptr);
29485 ZVAL_COPY_VALUE(arg, varptr);
29486 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29487 efree_size(ref, sizeof(zend_reference));
29488 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29489 Z_ADDREF_P(arg);
29490 }
29491 } else {
29492 ZVAL_COPY_VALUE(arg, varptr);
29493 }
29494 ZEND_VM_NEXT_OPCODE();
29495 }
29496
ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29497 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)
29498 {
29499 USE_OPLINE
29500 zval *varptr, *arg;
29501 uint32_t arg_num;
29502
29503 if (IS_UNUSED == IS_CONST) {
29504 SAVE_OPLINE();
29505 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29506 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29507 if (UNEXPECTED(!arg)) {
29508 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29509 HANDLE_EXCEPTION();
29510 }
29511 } else {
29512 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29513 arg_num = opline->op2.num;
29514 }
29515
29516 if (EXPECTED(1)) {
29517 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29518 goto send_var;
29519 }
29520
29521 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29522 ZVAL_COPY_VALUE(arg, varptr);
29523
29524 if (EXPECTED(Z_ISREF_P(varptr) ||
29525 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
29526 ZEND_VM_NEXT_OPCODE();
29527 }
29528 } else {
29529 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29530 goto send_var;
29531 }
29532
29533 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29534 ZVAL_COPY_VALUE(arg, varptr);
29535
29536 if (EXPECTED(Z_ISREF_P(varptr) ||
29537 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
29538 ZEND_VM_NEXT_OPCODE();
29539 }
29540 }
29541
29542 SAVE_OPLINE();
29543 ZVAL_NEW_REF(arg, arg);
29544 zend_error(E_NOTICE, "Only variables should be passed by reference");
29545 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29546
29547 send_var:
29548 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29549 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29550 zend_refcounted *ref = Z_COUNTED_P(varptr);
29551
29552 varptr = Z_REFVAL_P(varptr);
29553 ZVAL_COPY_VALUE(arg, varptr);
29554 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29555 efree_size(ref, sizeof(zend_reference));
29556 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29557 Z_ADDREF_P(arg);
29558 }
29559 } else {
29560 ZVAL_COPY_VALUE(arg, varptr);
29561 }
29562 ZEND_VM_NEXT_OPCODE();
29563 }
29564
ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29565 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29566 {
29567 USE_OPLINE
29568 zval *varptr, *arg;
29569
29570 SAVE_OPLINE();
29571 if (IS_UNUSED == IS_CONST) {
29572 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29573 uint32_t arg_num;
29574 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29575 if (UNEXPECTED(!arg)) {
29576 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29577 HANDLE_EXCEPTION();
29578 }
29579 } else {
29580 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29581 }
29582
29583 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29584 if (Z_ISREF_P(varptr)) {
29585 Z_ADDREF_P(varptr);
29586 } else {
29587 ZVAL_MAKE_REF_EX(varptr, 2);
29588 }
29589 ZVAL_REF(arg, Z_REF_P(varptr));
29590
29591 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29592 ZEND_VM_NEXT_OPCODE();
29593 }
29594
ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29595 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29596 {
29597 USE_OPLINE
29598 zval *varptr, *arg;
29599 uint32_t arg_num;
29600
29601 if (IS_UNUSED == IS_CONST) {
29602 SAVE_OPLINE();
29603 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29604 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29605 if (UNEXPECTED(!arg)) {
29606 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29607 HANDLE_EXCEPTION();
29608 }
29609 } else {
29610 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29611 arg_num = opline->op2.num;
29612 }
29613
29614 if (EXPECTED(0)) {
29615 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29616 goto send_var_by_ref;
29617 }
29618 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29619 send_var_by_ref:
29620 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29621 if (Z_ISREF_P(varptr)) {
29622 Z_ADDREF_P(varptr);
29623 } else {
29624 ZVAL_MAKE_REF_EX(varptr, 2);
29625 }
29626 ZVAL_REF(arg, Z_REF_P(varptr));
29627
29628 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29629 ZEND_VM_NEXT_OPCODE();
29630 }
29631
29632 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29633 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
29634 SAVE_OPLINE();
29635 ZVAL_UNDEFINED_OP1();
29636 ZVAL_NULL(arg);
29637 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29638 }
29639
29640 if (IS_VAR == IS_CV) {
29641 ZVAL_COPY_DEREF(arg, varptr);
29642 } else /* if (IS_VAR == IS_VAR) */ {
29643 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29644 zend_refcounted *ref = Z_COUNTED_P(varptr);
29645
29646 varptr = Z_REFVAL_P(varptr);
29647 ZVAL_COPY_VALUE(arg, varptr);
29648 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29649 efree_size(ref, sizeof(zend_reference));
29650 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29651 Z_ADDREF_P(arg);
29652 }
29653 } else {
29654 ZVAL_COPY_VALUE(arg, varptr);
29655 }
29656 }
29657
29658 ZEND_VM_NEXT_OPCODE();
29659 }
29660
ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29661 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29662 {
29663 USE_OPLINE
29664 zval *varptr, *arg;
29665 uint32_t arg_num;
29666
29667 if (IS_UNUSED == IS_CONST) {
29668 SAVE_OPLINE();
29669 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29670 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29671 if (UNEXPECTED(!arg)) {
29672 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29673 HANDLE_EXCEPTION();
29674 }
29675 } else {
29676 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29677 arg_num = opline->op2.num;
29678 }
29679
29680 if (EXPECTED(1)) {
29681 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29682 goto send_var_by_ref;
29683 }
29684 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29685 send_var_by_ref:
29686 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29687 if (Z_ISREF_P(varptr)) {
29688 Z_ADDREF_P(varptr);
29689 } else {
29690 ZVAL_MAKE_REF_EX(varptr, 2);
29691 }
29692 ZVAL_REF(arg, Z_REF_P(varptr));
29693
29694 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29695 ZEND_VM_NEXT_OPCODE();
29696 }
29697
29698 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29699 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
29700 SAVE_OPLINE();
29701 ZVAL_UNDEFINED_OP1();
29702 ZVAL_NULL(arg);
29703 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29704 }
29705
29706 if (IS_VAR == IS_CV) {
29707 ZVAL_COPY_DEREF(arg, varptr);
29708 } else /* if (IS_VAR == IS_VAR) */ {
29709 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29710 zend_refcounted *ref = Z_COUNTED_P(varptr);
29711
29712 varptr = Z_REFVAL_P(varptr);
29713 ZVAL_COPY_VALUE(arg, varptr);
29714 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29715 efree_size(ref, sizeof(zend_reference));
29716 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29717 Z_ADDREF_P(arg);
29718 }
29719 } else {
29720 ZVAL_COPY_VALUE(arg, varptr);
29721 }
29722 }
29723
29724 ZEND_VM_NEXT_OPCODE();
29725 }
29726
ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29727 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29728 {
29729 USE_OPLINE
29730 zval *varptr, *arg;
29731
29732 if (IS_UNUSED == IS_CONST) {
29733 // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
29734 SAVE_OPLINE();
29735 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29736 uint32_t arg_num;
29737 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29738 if (UNEXPECTED(!arg)) {
29739 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29740 HANDLE_EXCEPTION();
29741 }
29742 } else {
29743 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29744 }
29745
29746 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
29747 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29748 if (Z_ISREF_P(varptr)) {
29749 Z_ADDREF_P(varptr);
29750 } else {
29751 ZVAL_MAKE_REF_EX(varptr, 2);
29752 }
29753 ZVAL_REF(arg, Z_REF_P(varptr));
29754
29755 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29756 ZEND_VM_NEXT_OPCODE();
29757 }
29758
29759 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29760
29761 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29762 zend_refcounted *ref = Z_COUNTED_P(varptr);
29763
29764 varptr = Z_REFVAL_P(varptr);
29765 ZVAL_COPY_VALUE(arg, varptr);
29766 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29767 efree_size(ref, sizeof(zend_reference));
29768 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29769 Z_ADDREF_P(arg);
29770 }
29771 } else {
29772 ZVAL_COPY_VALUE(arg, varptr);
29773 }
29774
29775 ZEND_VM_NEXT_OPCODE();
29776 }
29777
ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29778 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29779 {
29780 USE_OPLINE
29781 zval *result;
29782 zend_function *constructor;
29783 zend_class_entry *ce;
29784 zend_execute_data *call;
29785
29786 SAVE_OPLINE();
29787 if (IS_VAR == IS_CONST) {
29788 ce = CACHED_PTR(opline->op2.num);
29789 if (UNEXPECTED(ce == NULL)) {
29790 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);
29791 if (UNEXPECTED(ce == NULL)) {
29792 ZVAL_UNDEF(EX_VAR(opline->result.var));
29793 HANDLE_EXCEPTION();
29794 }
29795 CACHE_PTR(opline->op2.num, ce);
29796 }
29797 } else if (IS_VAR == IS_UNUSED) {
29798 ce = zend_fetch_class(NULL, opline->op1.num);
29799 if (UNEXPECTED(ce == NULL)) {
29800 ZVAL_UNDEF(EX_VAR(opline->result.var));
29801 HANDLE_EXCEPTION();
29802 }
29803 } else {
29804 ce = Z_CE_P(EX_VAR(opline->op1.var));
29805 }
29806
29807 result = EX_VAR(opline->result.var);
29808 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
29809 ZVAL_UNDEF(result);
29810 HANDLE_EXCEPTION();
29811 }
29812
29813 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
29814 if (constructor == NULL) {
29815 if (UNEXPECTED(EG(exception))) {
29816 HANDLE_EXCEPTION();
29817 }
29818
29819 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
29820 * opcode is DO_FCALL in case EXT instructions are used. */
29821 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
29822 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29823 }
29824
29825 /* Perform a dummy function call */
29826 call = zend_vm_stack_push_call_frame(
29827 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
29828 opline->extended_value, NULL);
29829 } else {
29830 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
29831 init_func_run_time_cache(&constructor->op_array);
29832 }
29833 /* We are not handling overloaded classes right now */
29834 call = zend_vm_stack_push_call_frame(
29835 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
29836 constructor,
29837 opline->extended_value,
29838 Z_OBJ_P(result));
29839 Z_ADDREF_P(result);
29840 }
29841
29842 call->prev_execute_data = EX(call);
29843 EX(call) = call;
29844 ZEND_VM_NEXT_OPCODE();
29845 }
29846
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29847 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29848 {
29849 USE_OPLINE
29850 zval *expr_ptr, new_expr;
29851
29852 SAVE_OPLINE();
29853 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
29854 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
29855 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29856 if (Z_ISREF_P(expr_ptr)) {
29857 Z_ADDREF_P(expr_ptr);
29858 } else {
29859 ZVAL_MAKE_REF_EX(expr_ptr, 2);
29860 }
29861 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29862 } else {
29863 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29864 if (IS_VAR == IS_TMP_VAR) {
29865 /* pass */
29866 } else if (IS_VAR == IS_CONST) {
29867 Z_TRY_ADDREF_P(expr_ptr);
29868 } else if (IS_VAR == IS_CV) {
29869 ZVAL_DEREF(expr_ptr);
29870 Z_TRY_ADDREF_P(expr_ptr);
29871 } else /* if (IS_VAR == IS_VAR) */ {
29872 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
29873 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
29874
29875 expr_ptr = Z_REFVAL_P(expr_ptr);
29876 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29877 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
29878 expr_ptr = &new_expr;
29879 efree_size(ref, sizeof(zend_reference));
29880 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
29881 Z_ADDREF_P(expr_ptr);
29882 }
29883 }
29884 }
29885 }
29886
29887 if (IS_UNUSED != IS_UNUSED) {
29888 zval *offset = NULL;
29889 zend_string *str;
29890 zend_ulong hval;
29891
29892 add_again:
29893 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
29894 str = Z_STR_P(offset);
29895 if (IS_UNUSED != IS_CONST) {
29896 if (ZEND_HANDLE_NUMERIC(str, hval)) {
29897 goto num_index;
29898 }
29899 }
29900 str_index:
29901 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
29902 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
29903 hval = Z_LVAL_P(offset);
29904 num_index:
29905 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
29906 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
29907 offset = Z_REFVAL_P(offset);
29908 goto add_again;
29909 } else if (Z_TYPE_P(offset) == IS_NULL) {
29910 str = ZSTR_EMPTY_ALLOC();
29911 goto str_index;
29912 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
29913 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
29914 goto num_index;
29915 } else if (Z_TYPE_P(offset) == IS_FALSE) {
29916 hval = 0;
29917 goto num_index;
29918 } else if (Z_TYPE_P(offset) == IS_TRUE) {
29919 hval = 1;
29920 goto num_index;
29921 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
29922 zend_use_resource_as_offset(offset);
29923 hval = Z_RES_HANDLE_P(offset);
29924 goto num_index;
29925 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
29926 ZVAL_UNDEFINED_OP2();
29927 str = ZSTR_EMPTY_ALLOC();
29928 goto str_index;
29929 } else {
29930 zend_illegal_array_offset_access(offset);
29931 zval_ptr_dtor_nogc(expr_ptr);
29932 }
29933
29934 } else {
29935 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
29936 zend_cannot_add_element();
29937 zval_ptr_dtor_nogc(expr_ptr);
29938 }
29939 }
29940 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29941 }
29942
ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29943 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29944 {
29945 zval *array;
29946 uint32_t size;
29947 USE_OPLINE
29948
29949 array = EX_VAR(opline->result.var);
29950 if (IS_VAR != IS_UNUSED) {
29951 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
29952 ZVAL_ARR(array, zend_new_array(size));
29953 /* Explicitly initialize array as not-packed if flag is set */
29954 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
29955 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
29956 }
29957 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29958 } else {
29959 ZVAL_ARR(array, zend_new_array(0));
29960 ZEND_VM_NEXT_OPCODE();
29961 }
29962 }
29963
ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29964 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29965 {
29966 USE_OPLINE
29967 zval *var_ptr;
29968
29969 var_ptr = EX_VAR(opline->op1.var);
29970 if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
29971 if (UNEXPECTED(Z_REFCOUNT_P(var_ptr) == 1)) {
29972 ZVAL_UNREF(var_ptr);
29973 }
29974 }
29975
29976 ZEND_VM_NEXT_OPCODE();
29977 }
29978
ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29979 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29980 {
29981 USE_OPLINE
29982
29983 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
29984
29985 SAVE_OPLINE();
29986 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
29987 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29988 }
29989
29990 /* Destroy the previously yielded value */
29991 zval_ptr_dtor(&generator->value);
29992
29993 /* Destroy the previously yielded key */
29994 zval_ptr_dtor(&generator->key);
29995
29996 /* Set the new yielded value */
29997 if (IS_VAR != IS_UNUSED) {
29998 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
29999 /* Constants and temporary variables aren't yieldable by reference,
30000 * but we still allow them with a notice. */
30001 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
30002 zval *value;
30003
30004 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30005
30006 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30007 ZVAL_COPY_VALUE(&generator->value, value);
30008 if (IS_VAR == IS_CONST) {
30009 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30010 Z_ADDREF(generator->value);
30011 }
30012 }
30013 } else {
30014 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30015
30016 /* If a function call result is yielded and the function did
30017 * not return by reference we throw a notice. */
30018 do {
30019 if (IS_VAR == IS_VAR) {
30020 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
30021 if (opline->extended_value == ZEND_RETURNS_FUNCTION
30022 && !Z_ISREF_P(value_ptr)) {
30023 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30024 ZVAL_COPY(&generator->value, value_ptr);
30025 break;
30026 }
30027 }
30028 if (Z_ISREF_P(value_ptr)) {
30029 Z_ADDREF_P(value_ptr);
30030 } else {
30031 ZVAL_MAKE_REF_EX(value_ptr, 2);
30032 }
30033 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
30034 } while (0);
30035
30036 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30037 }
30038 } else {
30039 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30040
30041 /* Consts, temporary variables and references need copying */
30042 if (IS_VAR == IS_CONST) {
30043 ZVAL_COPY_VALUE(&generator->value, value);
30044 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30045 Z_ADDREF(generator->value);
30046 }
30047 } else if (IS_VAR == IS_TMP_VAR) {
30048 ZVAL_COPY_VALUE(&generator->value, value);
30049 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
30050 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
30051 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30052 } else {
30053 ZVAL_COPY_VALUE(&generator->value, value);
30054 if (IS_VAR == IS_CV) {
30055 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
30056 }
30057 }
30058 }
30059 } else {
30060 /* If no value was specified yield null */
30061 ZVAL_NULL(&generator->value);
30062 }
30063
30064 /* Set the new yielded key */
30065 if (IS_UNUSED != IS_UNUSED) {
30066 zval *key = NULL;
30067 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
30068 key = Z_REFVAL_P(key);
30069 }
30070 ZVAL_COPY(&generator->key, key);
30071
30072 if (Z_TYPE(generator->key) == IS_LONG
30073 && Z_LVAL(generator->key) > generator->largest_used_integer_key
30074 ) {
30075 generator->largest_used_integer_key = Z_LVAL(generator->key);
30076 }
30077 } else {
30078 /* If no key was specified we use auto-increment keys */
30079 generator->largest_used_integer_key++;
30080 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
30081 }
30082
30083 if (RETURN_VALUE_USED(opline)) {
30084 /* If the return value of yield is used set the send
30085 * target and initialize it to NULL */
30086 generator->send_target = EX_VAR(opline->result.var);
30087 ZVAL_NULL(generator->send_target);
30088 } else {
30089 generator->send_target = NULL;
30090 }
30091
30092 /* We increment to the next op, so we are at the correct position when the
30093 * generator is resumed. */
30094 ZEND_VM_INC_OPCODE();
30095
30096 /* The GOTO VM uses a local opline variable. We need to set the opline
30097 * variable in execute_data so we don't resume at an old position. */
30098 SAVE_OPLINE();
30099
30100 ZEND_VM_RETURN();
30101 }
30102
ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30103 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30104 {
30105 USE_OPLINE
30106 zval *op1 = EX_VAR(opline->op1.var);
30107
30108 if (IS_VAR == IS_CV) {
30109 if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
30110 ZVAL_NEW_EMPTY_REF(op1);
30111 Z_SET_REFCOUNT_P(op1, 2);
30112 ZVAL_NULL(Z_REFVAL_P(op1));
30113 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30114 } else {
30115 if (Z_ISREF_P(op1)) {
30116 Z_ADDREF_P(op1);
30117 } else {
30118 ZVAL_MAKE_REF_EX(op1, 2);
30119 }
30120 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30121 }
30122 } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
30123 op1 = Z_INDIRECT_P(op1);
30124 if (EXPECTED(!Z_ISREF_P(op1))) {
30125 ZVAL_MAKE_REF_EX(op1, 2);
30126 } else {
30127 GC_ADDREF(Z_REF_P(op1));
30128 }
30129 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30130 } else {
30131 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
30132 }
30133 ZEND_VM_NEXT_OPCODE();
30134 }
30135
ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30136 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30137 {
30138 USE_OPLINE
30139 zval *op1;
30140 zend_string *type;
30141
30142 SAVE_OPLINE();
30143 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30144 type = zend_zval_get_legacy_type(op1);
30145 if (EXPECTED(type)) {
30146 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
30147 } else {
30148 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
30149 }
30150 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30151 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30152 }
30153
ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30154 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30155 {
30156 USE_OPLINE
30157 zval *varptr, *arg;
30158 uint32_t arg_num = opline->op2.num;
30159
30160 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30161 ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30162 }
30163
30164 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30165 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30166
30167 if (IS_VAR == IS_CV) {
30168 ZVAL_COPY(arg, varptr);
30169 } else /* if (IS_VAR == IS_VAR) */ {
30170 ZVAL_COPY_VALUE(arg, varptr);
30171 }
30172
30173 ZEND_VM_NEXT_OPCODE();
30174 }
30175
ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30176 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30177 {
30178 USE_OPLINE
30179 zval *op1, *op2;
30180 bool result;
30181
30182 SAVE_OPLINE();
30183 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30184 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30185 result = fast_is_identical_function(op1, op2);
30186
30187 ZEND_VM_SMART_BRANCH(result, 1);
30188 }
30189
ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30190 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30191 {
30192 USE_OPLINE
30193 zval *object;
30194 zval *property;
30195 zval *value;
30196 zval *zptr;
30197 void **cache_slot;
30198 zend_property_info *prop_info;
30199 zend_object *zobj;
30200 zend_string *name, *tmp_name;
30201
30202 SAVE_OPLINE();
30203 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30204 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30205
30206 do {
30207 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
30208
30209 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30210 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30211 object = Z_REFVAL_P(object);
30212 goto assign_op_object;
30213 }
30214 if (IS_VAR == IS_CV
30215 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
30216 ZVAL_UNDEFINED_OP1();
30217 }
30218 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
30219 break;
30220 }
30221
30222 assign_op_object:
30223 /* here we are sure we are dealing with an object */
30224 zobj = Z_OBJ_P(object);
30225 if (IS_CV == IS_CONST) {
30226 name = Z_STR_P(property);
30227 } else {
30228 name = zval_try_get_tmp_string(property, &tmp_name);
30229 if (UNEXPECTED(!name)) {
30230 UNDEF_RESULT();
30231 break;
30232 }
30233 }
30234 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
30235 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
30236 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
30237 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30238 ZVAL_NULL(EX_VAR(opline->result.var));
30239 }
30240 } else {
30241 zval *orig_zptr = zptr;
30242 zend_reference *ref;
30243
30244 do {
30245 if (UNEXPECTED(Z_ISREF_P(zptr))) {
30246 ref = Z_REF_P(zptr);
30247 zptr = Z_REFVAL_P(zptr);
30248 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
30249 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
30250 break;
30251 }
30252 }
30253
30254 if (IS_CV == IS_CONST) {
30255 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
30256 } else {
30257 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
30258 }
30259 if (prop_info) {
30260 /* special case for typed properties */
30261 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
30262 } else {
30263 zend_binary_op(zptr, zptr, value OPLINE_CC);
30264 }
30265 } while (0);
30266
30267 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30268 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
30269 }
30270 }
30271 } else {
30272 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
30273 }
30274 if (IS_CV != IS_CONST) {
30275 zend_tmp_string_release(tmp_name);
30276 }
30277 } while (0);
30278
30279 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
30280
30281 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30282 /* assign_obj has two opcodes! */
30283 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30284 }
30285
30286 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30287 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30288 {
30289 USE_OPLINE
30290 zval *var_ptr;
30291 zval *value, *container, *dim;
30292 HashTable *ht;
30293
30294 SAVE_OPLINE();
30295 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30296
30297 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
30298 assign_dim_op_array:
30299 SEPARATE_ARRAY(container);
30300 ht = Z_ARRVAL_P(container);
30301 assign_dim_op_new_array:
30302 dim = EX_VAR(opline->op2.var);
30303 if (IS_CV == IS_UNUSED) {
30304 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
30305 if (UNEXPECTED(!var_ptr)) {
30306 zend_cannot_add_element();
30307 goto assign_dim_op_ret_null;
30308 }
30309 } else {
30310 if (IS_CV == IS_CONST) {
30311 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
30312 } else {
30313 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
30314 }
30315 if (UNEXPECTED(!var_ptr)) {
30316 goto assign_dim_op_ret_null;
30317 }
30318 }
30319
30320 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
30321
30322 do {
30323 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
30324 zend_reference *ref = Z_REF_P(var_ptr);
30325 var_ptr = Z_REFVAL_P(var_ptr);
30326 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
30327 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
30328 break;
30329 }
30330 }
30331 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
30332 } while (0);
30333
30334 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30335 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
30336 }
30337 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
30338 } else {
30339 if (EXPECTED(Z_ISREF_P(container))) {
30340 container = Z_REFVAL_P(container);
30341 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
30342 goto assign_dim_op_array;
30343 }
30344 }
30345
30346 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
30347 zend_object *obj = Z_OBJ_P(container);
30348
30349 dim = EX_VAR(opline->op2.var);
30350 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
30351 dim++;
30352 }
30353 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
30354 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
30355 uint8_t old_type;
30356
30357 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
30358 ZVAL_UNDEFINED_OP1();
30359 }
30360 ht = zend_new_array(8);
30361 old_type = Z_TYPE_P(container);
30362 ZVAL_ARR(container, ht);
30363 if (UNEXPECTED(old_type == IS_FALSE)) {
30364 GC_ADDREF(ht);
30365 zend_false_to_array_deprecated();
30366 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
30367 zend_array_destroy(ht);
30368 goto assign_dim_op_ret_null;
30369 }
30370 }
30371 goto assign_dim_op_new_array;
30372 } else {
30373 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30374 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
30375 assign_dim_op_ret_null:
30376 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
30377 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30378 ZVAL_NULL(EX_VAR(opline->result.var));
30379 }
30380 }
30381 }
30382
30383 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30384 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30385 }
30386
ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30387 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30388 {
30389 USE_OPLINE
30390 zval *var_ptr;
30391 zval *value;
30392
30393 SAVE_OPLINE();
30394 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30395 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30396
30397 do {
30398 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
30399 zend_reference *ref = Z_REF_P(var_ptr);
30400 var_ptr = Z_REFVAL_P(var_ptr);
30401 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
30402 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
30403 break;
30404 }
30405 }
30406 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
30407 } while (0);
30408
30409 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30410 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
30411 }
30412
30413 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30414 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30415 }
30416
ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30417 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30418 {
30419 USE_OPLINE
30420 zval *object;
30421 zval *property;
30422 zval *zptr;
30423 void **cache_slot;
30424 zend_property_info *prop_info;
30425 zend_object *zobj;
30426 zend_string *name, *tmp_name;
30427
30428 SAVE_OPLINE();
30429 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30430 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30431
30432 do {
30433 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30434 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30435 object = Z_REFVAL_P(object);
30436 goto pre_incdec_object;
30437 }
30438 if (IS_VAR == IS_CV
30439 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
30440 ZVAL_UNDEFINED_OP1();
30441 }
30442 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
30443 break;
30444 }
30445
30446 pre_incdec_object:
30447 /* here we are sure we are dealing with an object */
30448 zobj = Z_OBJ_P(object);
30449 if (IS_CV == IS_CONST) {
30450 name = Z_STR_P(property);
30451 } else {
30452 name = zval_try_get_tmp_string(property, &tmp_name);
30453 if (UNEXPECTED(!name)) {
30454 UNDEF_RESULT();
30455 break;
30456 }
30457 }
30458 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
30459 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
30460 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
30461 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30462 ZVAL_NULL(EX_VAR(opline->result.var));
30463 }
30464 } else {
30465 if (IS_CV == IS_CONST) {
30466 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
30467 } else {
30468 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
30469 }
30470 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
30471 }
30472 } else {
30473 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
30474 }
30475 if (IS_CV != IS_CONST) {
30476 zend_tmp_string_release(tmp_name);
30477 }
30478 } while (0);
30479
30480 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30481 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30482 }
30483
ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30484 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30485 {
30486 USE_OPLINE
30487 zval *object;
30488 zval *property;
30489 zval *zptr;
30490 void **cache_slot;
30491 zend_property_info *prop_info;
30492 zend_object *zobj;
30493 zend_string *name, *tmp_name;
30494
30495 SAVE_OPLINE();
30496 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30497 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30498
30499 do {
30500 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30501 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30502 object = Z_REFVAL_P(object);
30503 goto post_incdec_object;
30504 }
30505 if (IS_VAR == IS_CV
30506 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
30507 ZVAL_UNDEFINED_OP1();
30508 }
30509 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
30510 break;
30511 }
30512
30513 post_incdec_object:
30514 /* here we are sure we are dealing with an object */
30515 zobj = Z_OBJ_P(object);
30516 if (IS_CV == IS_CONST) {
30517 name = Z_STR_P(property);
30518 } else {
30519 name = zval_try_get_tmp_string(property, &tmp_name);
30520 if (UNEXPECTED(!name)) {
30521 ZVAL_UNDEF(EX_VAR(opline->result.var));
30522 break;
30523 }
30524 }
30525 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
30526 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
30527 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
30528 ZVAL_NULL(EX_VAR(opline->result.var));
30529 } else {
30530 if (IS_CV == IS_CONST) {
30531 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
30532 } else {
30533 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
30534 }
30535
30536 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
30537 }
30538 } else {
30539 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
30540 }
30541 if (IS_CV != IS_CONST) {
30542 zend_tmp_string_release(tmp_name);
30543 }
30544 } while (0);
30545
30546 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30547 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30548 }
30549
ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30550 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30551 {
30552 USE_OPLINE
30553 zval *container;
30554
30555 SAVE_OPLINE();
30556 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30557 zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
30558
30559 if (IS_VAR == IS_VAR) {
30560 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30561 }
30562 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30563 }
30564
ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30565 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30566 {
30567 USE_OPLINE
30568 zval *container;
30569
30570 SAVE_OPLINE();
30571 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30572 zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
30573
30574 if (IS_VAR == IS_VAR) {
30575 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30576 }
30577 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30578 }
30579
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30580 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30581 {
30582 #if 0
30583 USE_OPLINE
30584 #endif
30585
30586 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
30587 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
30588 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30589 }
30590 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30591 } else {
30592 if (IS_CV == IS_UNUSED) {
30593 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30594 }
30595 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30596 }
30597 }
30598
ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30599 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30600 {
30601 USE_OPLINE
30602 zval *container;
30603
30604 SAVE_OPLINE();
30605 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30606 zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
30607
30608 if (IS_VAR == IS_VAR) {
30609 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30610 }
30611 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30612 }
30613
ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30614 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30615 {
30616 USE_OPLINE
30617 zval *property, *container, *result;
30618
30619 SAVE_OPLINE();
30620
30621 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30622 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30623 result = EX_VAR(opline->result.var);
30624 zend_fetch_property_address(
30625 result, container, IS_VAR, property, IS_CV,
30626 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
30627 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
30628
30629 if (IS_VAR == IS_VAR) {
30630 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30631 }
30632 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30633 }
30634
ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30635 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30636 {
30637 USE_OPLINE
30638 zval *property, *container, *result;
30639
30640 SAVE_OPLINE();
30641 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30642 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30643 result = EX_VAR(opline->result.var);
30644 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);
30645
30646 if (IS_VAR == IS_VAR) {
30647 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30648 }
30649 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30650 }
30651
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30652 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30653 {
30654 #if 0
30655 USE_OPLINE
30656 #endif
30657
30658 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
30659 /* Behave like FETCH_OBJ_W */
30660 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
30661 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30662 }
30663 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30664 } else {
30665 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30666 }
30667 }
30668
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30669 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30670 {
30671 USE_OPLINE
30672 zval *container, *property, *result;
30673
30674 SAVE_OPLINE();
30675 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30676 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30677 result = EX_VAR(opline->result.var);
30678 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);
30679
30680 if (IS_VAR == IS_VAR) {
30681 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30682 }
30683 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30684 }
30685
ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30686 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30687 {
30688 USE_OPLINE
30689 zval *container, *dim;
30690
30691 SAVE_OPLINE();
30692 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30693 dim = EX_VAR(opline->op2.var);
30694
30695 if (IS_VAR == IS_VAR
30696 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
30697 && UNEXPECTED(!Z_ISREF_P(container))
30698 ) {
30699 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
30700 zend_fetch_dimension_address_LIST_r(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
30701 } else {
30702 zend_fetch_dimension_address_W(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
30703 }
30704
30705 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30706 }
30707
ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30708 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30709 {
30710 USE_OPLINE
30711 zval *object, *value, tmp;
30712 zend_object *zobj;
30713 zend_string *name, *tmp_name;
30714 zend_refcounted *garbage = NULL;
30715
30716 SAVE_OPLINE();
30717 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30718 value = RT_CONSTANT((opline+1), (opline+1)->op1);
30719
30720 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30721 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30722 object = Z_REFVAL_P(object);
30723 goto assign_object;
30724 }
30725 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
30726 value = &EG(uninitialized_zval);
30727 goto free_and_exit_assign_obj;
30728 }
30729
30730 assign_object:
30731 zobj = Z_OBJ_P(object);
30732 if (IS_CV == IS_CONST) {
30733 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
30734 void **cache_slot = CACHE_ADDR(opline->extended_value);
30735 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
30736 zval *property_val;
30737
30738 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
30739 property_val = OBJ_PROP(zobj, prop_offset);
30740 if (Z_TYPE_P(property_val) != IS_UNDEF) {
30741 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
30742
30743 if (prop_info != NULL) {
30744 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
30745 goto free_and_exit_assign_obj;
30746 } else {
30747 fast_assign_obj:
30748 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
30749 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30750 ZVAL_COPY(EX_VAR(opline->result.var), value);
30751 }
30752 goto exit_assign_obj;
30753 }
30754 }
30755 } else {
30756 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
30757 if (EXPECTED(zobj->properties != NULL)) {
30758 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
30759 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
30760 GC_DELREF(zobj->properties);
30761 }
30762 zobj->properties = zend_array_dup(zobj->properties);
30763 }
30764 property_val = zend_hash_find_known_hash(zobj->properties, name);
30765 if (property_val) {
30766 goto fast_assign_obj;
30767 }
30768 }
30769
30770 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
30771 if (EXPECTED(zobj->properties == NULL)) {
30772 rebuild_object_properties(zobj);
30773 }
30774 if (IS_CONST == IS_CONST) {
30775 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
30776 Z_ADDREF_P(value);
30777 }
30778 } else if (IS_CONST != IS_TMP_VAR) {
30779 if (Z_ISREF_P(value)) {
30780 if (IS_CONST == IS_VAR) {
30781 zend_reference *ref = Z_REF_P(value);
30782 if (GC_DELREF(ref) == 0) {
30783 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
30784 efree_size(ref, sizeof(zend_reference));
30785 value = &tmp;
30786 } else {
30787 value = Z_REFVAL_P(value);
30788 Z_TRY_ADDREF_P(value);
30789 }
30790 } else {
30791 value = Z_REFVAL_P(value);
30792 Z_TRY_ADDREF_P(value);
30793 }
30794 } else if (IS_CONST == IS_CV) {
30795 Z_TRY_ADDREF_P(value);
30796 }
30797 }
30798 zend_hash_add_new(zobj->properties, name, value);
30799 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30800 ZVAL_COPY(EX_VAR(opline->result.var), value);
30801 }
30802 goto exit_assign_obj;
30803 }
30804 }
30805 }
30806 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
30807 } else {
30808 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
30809 if (UNEXPECTED(!name)) {
30810
30811 UNDEF_RESULT();
30812 goto exit_assign_obj;
30813 }
30814 }
30815
30816 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
30817 ZVAL_DEREF(value);
30818 }
30819
30820 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
30821
30822 if (IS_CV != IS_CONST) {
30823 zend_tmp_string_release(tmp_name);
30824 }
30825
30826 free_and_exit_assign_obj:
30827 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
30828 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
30829 }
30830
30831 exit_assign_obj:
30832 if (garbage) {
30833 GC_DTOR_NO_REF(garbage);
30834 }
30835
30836 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30837 /* assign_obj has two opcodes! */
30838 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30839 }
30840
30841 /* 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)30842 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30843 {
30844 USE_OPLINE
30845 zval *object, *value, tmp;
30846 zend_object *zobj;
30847 zend_string *name, *tmp_name;
30848 zend_refcounted *garbage = NULL;
30849
30850 SAVE_OPLINE();
30851 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30852 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
30853
30854 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30855 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30856 object = Z_REFVAL_P(object);
30857 goto assign_object;
30858 }
30859 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
30860 value = &EG(uninitialized_zval);
30861 goto free_and_exit_assign_obj;
30862 }
30863
30864 assign_object:
30865 zobj = Z_OBJ_P(object);
30866 if (IS_CV == IS_CONST) {
30867 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
30868 void **cache_slot = CACHE_ADDR(opline->extended_value);
30869 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
30870 zval *property_val;
30871
30872 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
30873 property_val = OBJ_PROP(zobj, prop_offset);
30874 if (Z_TYPE_P(property_val) != IS_UNDEF) {
30875 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
30876
30877 if (prop_info != NULL) {
30878 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
30879 goto free_and_exit_assign_obj;
30880 } else {
30881 fast_assign_obj:
30882 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
30883 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30884 ZVAL_COPY(EX_VAR(opline->result.var), value);
30885 }
30886 goto exit_assign_obj;
30887 }
30888 }
30889 } else {
30890 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
30891 if (EXPECTED(zobj->properties != NULL)) {
30892 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
30893 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
30894 GC_DELREF(zobj->properties);
30895 }
30896 zobj->properties = zend_array_dup(zobj->properties);
30897 }
30898 property_val = zend_hash_find_known_hash(zobj->properties, name);
30899 if (property_val) {
30900 goto fast_assign_obj;
30901 }
30902 }
30903
30904 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
30905 if (EXPECTED(zobj->properties == NULL)) {
30906 rebuild_object_properties(zobj);
30907 }
30908 if (IS_TMP_VAR == IS_CONST) {
30909 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
30910 Z_ADDREF_P(value);
30911 }
30912 } else if (IS_TMP_VAR != IS_TMP_VAR) {
30913 if (Z_ISREF_P(value)) {
30914 if (IS_TMP_VAR == IS_VAR) {
30915 zend_reference *ref = Z_REF_P(value);
30916 if (GC_DELREF(ref) == 0) {
30917 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
30918 efree_size(ref, sizeof(zend_reference));
30919 value = &tmp;
30920 } else {
30921 value = Z_REFVAL_P(value);
30922 Z_TRY_ADDREF_P(value);
30923 }
30924 } else {
30925 value = Z_REFVAL_P(value);
30926 Z_TRY_ADDREF_P(value);
30927 }
30928 } else if (IS_TMP_VAR == IS_CV) {
30929 Z_TRY_ADDREF_P(value);
30930 }
30931 }
30932 zend_hash_add_new(zobj->properties, name, value);
30933 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30934 ZVAL_COPY(EX_VAR(opline->result.var), value);
30935 }
30936 goto exit_assign_obj;
30937 }
30938 }
30939 }
30940 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
30941 } else {
30942 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
30943 if (UNEXPECTED(!name)) {
30944 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
30945 UNDEF_RESULT();
30946 goto exit_assign_obj;
30947 }
30948 }
30949
30950 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
30951 ZVAL_DEREF(value);
30952 }
30953
30954 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
30955
30956 if (IS_CV != IS_CONST) {
30957 zend_tmp_string_release(tmp_name);
30958 }
30959
30960 free_and_exit_assign_obj:
30961 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
30962 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
30963 }
30964 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
30965 exit_assign_obj:
30966 if (garbage) {
30967 GC_DTOR_NO_REF(garbage);
30968 }
30969
30970 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30971 /* assign_obj has two opcodes! */
30972 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30973 }
30974
30975 /* 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)30976 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30977 {
30978 USE_OPLINE
30979 zval *object, *value, tmp;
30980 zend_object *zobj;
30981 zend_string *name, *tmp_name;
30982 zend_refcounted *garbage = NULL;
30983
30984 SAVE_OPLINE();
30985 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30986 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
30987
30988 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30989 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30990 object = Z_REFVAL_P(object);
30991 goto assign_object;
30992 }
30993 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
30994 value = &EG(uninitialized_zval);
30995 goto free_and_exit_assign_obj;
30996 }
30997
30998 assign_object:
30999 zobj = Z_OBJ_P(object);
31000 if (IS_CV == IS_CONST) {
31001 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31002 void **cache_slot = CACHE_ADDR(opline->extended_value);
31003 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31004 zval *property_val;
31005
31006 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31007 property_val = OBJ_PROP(zobj, prop_offset);
31008 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31009 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31010
31011 if (prop_info != NULL) {
31012 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31013 goto free_and_exit_assign_obj;
31014 } else {
31015 fast_assign_obj:
31016 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
31017 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31018 ZVAL_COPY(EX_VAR(opline->result.var), value);
31019 }
31020 goto exit_assign_obj;
31021 }
31022 }
31023 } else {
31024 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31025 if (EXPECTED(zobj->properties != NULL)) {
31026 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31027 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31028 GC_DELREF(zobj->properties);
31029 }
31030 zobj->properties = zend_array_dup(zobj->properties);
31031 }
31032 property_val = zend_hash_find_known_hash(zobj->properties, name);
31033 if (property_val) {
31034 goto fast_assign_obj;
31035 }
31036 }
31037
31038 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31039 if (EXPECTED(zobj->properties == NULL)) {
31040 rebuild_object_properties(zobj);
31041 }
31042 if (IS_VAR == IS_CONST) {
31043 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31044 Z_ADDREF_P(value);
31045 }
31046 } else if (IS_VAR != IS_TMP_VAR) {
31047 if (Z_ISREF_P(value)) {
31048 if (IS_VAR == IS_VAR) {
31049 zend_reference *ref = Z_REF_P(value);
31050 if (GC_DELREF(ref) == 0) {
31051 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31052 efree_size(ref, sizeof(zend_reference));
31053 value = &tmp;
31054 } else {
31055 value = Z_REFVAL_P(value);
31056 Z_TRY_ADDREF_P(value);
31057 }
31058 } else {
31059 value = Z_REFVAL_P(value);
31060 Z_TRY_ADDREF_P(value);
31061 }
31062 } else if (IS_VAR == IS_CV) {
31063 Z_TRY_ADDREF_P(value);
31064 }
31065 }
31066 zend_hash_add_new(zobj->properties, name, value);
31067 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31068 ZVAL_COPY(EX_VAR(opline->result.var), value);
31069 }
31070 goto exit_assign_obj;
31071 }
31072 }
31073 }
31074 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31075 } else {
31076 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31077 if (UNEXPECTED(!name)) {
31078 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31079 UNDEF_RESULT();
31080 goto exit_assign_obj;
31081 }
31082 }
31083
31084 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
31085 ZVAL_DEREF(value);
31086 }
31087
31088 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31089
31090 if (IS_CV != IS_CONST) {
31091 zend_tmp_string_release(tmp_name);
31092 }
31093
31094 free_and_exit_assign_obj:
31095 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31096 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31097 }
31098 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31099 exit_assign_obj:
31100 if (garbage) {
31101 GC_DTOR_NO_REF(garbage);
31102 }
31103
31104 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31105 /* assign_obj has two opcodes! */
31106 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31107 }
31108
31109 /* 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)31110 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31111 {
31112 USE_OPLINE
31113 zval *object, *value, tmp;
31114 zend_object *zobj;
31115 zend_string *name, *tmp_name;
31116 zend_refcounted *garbage = NULL;
31117
31118 SAVE_OPLINE();
31119 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31120 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
31121
31122 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31123 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31124 object = Z_REFVAL_P(object);
31125 goto assign_object;
31126 }
31127 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31128 value = &EG(uninitialized_zval);
31129 goto free_and_exit_assign_obj;
31130 }
31131
31132 assign_object:
31133 zobj = Z_OBJ_P(object);
31134 if (IS_CV == IS_CONST) {
31135 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31136 void **cache_slot = CACHE_ADDR(opline->extended_value);
31137 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31138 zval *property_val;
31139
31140 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31141 property_val = OBJ_PROP(zobj, prop_offset);
31142 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31143 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31144
31145 if (prop_info != NULL) {
31146 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31147 goto free_and_exit_assign_obj;
31148 } else {
31149 fast_assign_obj:
31150 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31151 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31152 ZVAL_COPY(EX_VAR(opline->result.var), value);
31153 }
31154 goto exit_assign_obj;
31155 }
31156 }
31157 } else {
31158 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31159 if (EXPECTED(zobj->properties != NULL)) {
31160 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31161 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31162 GC_DELREF(zobj->properties);
31163 }
31164 zobj->properties = zend_array_dup(zobj->properties);
31165 }
31166 property_val = zend_hash_find_known_hash(zobj->properties, name);
31167 if (property_val) {
31168 goto fast_assign_obj;
31169 }
31170 }
31171
31172 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31173 if (EXPECTED(zobj->properties == NULL)) {
31174 rebuild_object_properties(zobj);
31175 }
31176 if (IS_CV == IS_CONST) {
31177 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31178 Z_ADDREF_P(value);
31179 }
31180 } else if (IS_CV != IS_TMP_VAR) {
31181 if (Z_ISREF_P(value)) {
31182 if (IS_CV == IS_VAR) {
31183 zend_reference *ref = Z_REF_P(value);
31184 if (GC_DELREF(ref) == 0) {
31185 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31186 efree_size(ref, sizeof(zend_reference));
31187 value = &tmp;
31188 } else {
31189 value = Z_REFVAL_P(value);
31190 Z_TRY_ADDREF_P(value);
31191 }
31192 } else {
31193 value = Z_REFVAL_P(value);
31194 Z_TRY_ADDREF_P(value);
31195 }
31196 } else if (IS_CV == IS_CV) {
31197 Z_TRY_ADDREF_P(value);
31198 }
31199 }
31200 zend_hash_add_new(zobj->properties, name, value);
31201 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31202 ZVAL_COPY(EX_VAR(opline->result.var), value);
31203 }
31204 goto exit_assign_obj;
31205 }
31206 }
31207 }
31208 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31209 } else {
31210 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31211 if (UNEXPECTED(!name)) {
31212
31213 UNDEF_RESULT();
31214 goto exit_assign_obj;
31215 }
31216 }
31217
31218 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
31219 ZVAL_DEREF(value);
31220 }
31221
31222 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31223
31224 if (IS_CV != IS_CONST) {
31225 zend_tmp_string_release(tmp_name);
31226 }
31227
31228 free_and_exit_assign_obj:
31229 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31230 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31231 }
31232
31233 exit_assign_obj:
31234 if (garbage) {
31235 GC_DTOR_NO_REF(garbage);
31236 }
31237
31238 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31239 /* assign_obj has two opcodes! */
31240 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31241 }
31242
31243 /* 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)31244 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31245 {
31246 USE_OPLINE
31247 zval *object_ptr, *orig_object_ptr;
31248 zval *value;
31249 zval *variable_ptr;
31250 zval *dim;
31251 zend_refcounted *garbage = NULL;
31252
31253 SAVE_OPLINE();
31254 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31255
31256 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31257 try_assign_dim_array:
31258 SEPARATE_ARRAY(object_ptr);
31259 if (IS_CV == IS_UNUSED) {
31260 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31261 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
31262 HashTable *ht = Z_ARRVAL_P(object_ptr);
31263 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
31264 GC_ADDREF(ht);
31265 }
31266 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31267 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
31268 zend_array_destroy(ht);
31269 goto assign_dim_error;
31270 }
31271 }
31272 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
31273 ZVAL_DEREF(value);
31274 }
31275 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
31276 if (UNEXPECTED(value == NULL)) {
31277 zend_cannot_add_element();
31278 goto assign_dim_error;
31279 } else if (IS_CONST == IS_CV) {
31280 if (Z_REFCOUNTED_P(value)) {
31281 Z_ADDREF_P(value);
31282 }
31283 } else if (IS_CONST == IS_VAR) {
31284 zval *free_op_data = EX_VAR((opline+1)->op1.var);
31285 if (Z_ISREF_P(free_op_data)) {
31286 if (Z_REFCOUNTED_P(value)) {
31287 Z_ADDREF_P(value);
31288 }
31289 zval_ptr_dtor_nogc(free_op_data);
31290 }
31291 } else if (IS_CONST == IS_CONST) {
31292 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
31293 Z_ADDREF_P(value);
31294 }
31295 }
31296 } else {
31297 dim = EX_VAR(opline->op2.var);
31298 if (IS_CV == IS_CONST) {
31299 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31300 } else {
31301 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31302 }
31303 if (UNEXPECTED(variable_ptr == NULL)) {
31304 goto assign_dim_error;
31305 }
31306 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31307 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
31308 }
31309 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31310 ZVAL_COPY(EX_VAR(opline->result.var), value);
31311 }
31312 if (garbage) {
31313 GC_DTOR_NO_REF(garbage);
31314 }
31315 } else {
31316 if (EXPECTED(Z_ISREF_P(object_ptr))) {
31317 object_ptr = Z_REFVAL_P(object_ptr);
31318 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31319 goto try_assign_dim_array;
31320 }
31321 }
31322 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
31323 zend_object *obj = Z_OBJ_P(object_ptr);
31324
31325 GC_ADDREF(obj);
31326 dim = EX_VAR(opline->op2.var);
31327 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
31328 dim = ZVAL_UNDEFINED_OP2();
31329 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31330 dim++;
31331 }
31332
31333 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31334 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
31335 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31336 } else if (IS_CONST & (IS_CV|IS_VAR)) {
31337 ZVAL_DEREF(value);
31338 }
31339
31340 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
31341
31342 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
31343 zend_objects_store_del(obj);
31344 }
31345 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
31346 if (IS_CV == IS_UNUSED) {
31347 zend_use_new_element_for_string();
31348
31349 UNDEF_RESULT();
31350 } else {
31351 dim = EX_VAR(opline->op2.var);
31352 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31353 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
31354
31355 }
31356 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
31357 if (Z_ISREF_P(orig_object_ptr)
31358 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
31359 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
31360 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31361
31362 UNDEF_RESULT();
31363 } else {
31364 HashTable *ht = zend_new_array(8);
31365 uint8_t old_type = Z_TYPE_P(object_ptr);
31366
31367 ZVAL_ARR(object_ptr, ht);
31368 if (UNEXPECTED(old_type == IS_FALSE)) {
31369 GC_ADDREF(ht);
31370 zend_false_to_array_deprecated();
31371 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31372 zend_array_destroy(ht);
31373 goto assign_dim_error;
31374 }
31375 }
31376 goto try_assign_dim_array;
31377 }
31378 } else {
31379 zend_use_scalar_as_array();
31380 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31381 assign_dim_error:
31382
31383 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31384 ZVAL_NULL(EX_VAR(opline->result.var));
31385 }
31386 }
31387 }
31388 if (IS_CV != IS_UNUSED) {
31389
31390 }
31391 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31392 /* assign_dim has two opcodes! */
31393 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31394 }
31395
ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31396 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31397 {
31398 USE_OPLINE
31399 zval *object_ptr, *orig_object_ptr;
31400 zval *value;
31401 zval *variable_ptr;
31402 zval *dim;
31403 zend_refcounted *garbage = NULL;
31404
31405 SAVE_OPLINE();
31406 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31407
31408 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31409 try_assign_dim_array:
31410 SEPARATE_ARRAY(object_ptr);
31411 if (IS_CV == IS_UNUSED) {
31412 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31413 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
31414 HashTable *ht = Z_ARRVAL_P(object_ptr);
31415 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
31416 GC_ADDREF(ht);
31417 }
31418 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31419 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
31420 zend_array_destroy(ht);
31421 goto assign_dim_error;
31422 }
31423 }
31424 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
31425 ZVAL_DEREF(value);
31426 }
31427 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
31428 if (UNEXPECTED(value == NULL)) {
31429 zend_cannot_add_element();
31430 goto assign_dim_error;
31431 } else if (IS_TMP_VAR == IS_CV) {
31432 if (Z_REFCOUNTED_P(value)) {
31433 Z_ADDREF_P(value);
31434 }
31435 } else if (IS_TMP_VAR == IS_VAR) {
31436 zval *free_op_data = EX_VAR((opline+1)->op1.var);
31437 if (Z_ISREF_P(free_op_data)) {
31438 if (Z_REFCOUNTED_P(value)) {
31439 Z_ADDREF_P(value);
31440 }
31441 zval_ptr_dtor_nogc(free_op_data);
31442 }
31443 } else if (IS_TMP_VAR == IS_CONST) {
31444 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
31445 Z_ADDREF_P(value);
31446 }
31447 }
31448 } else {
31449 dim = EX_VAR(opline->op2.var);
31450 if (IS_CV == IS_CONST) {
31451 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31452 } else {
31453 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31454 }
31455 if (UNEXPECTED(variable_ptr == NULL)) {
31456 goto assign_dim_error;
31457 }
31458 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31459 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
31460 }
31461 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31462 ZVAL_COPY(EX_VAR(opline->result.var), value);
31463 }
31464 if (garbage) {
31465 GC_DTOR_NO_REF(garbage);
31466 }
31467 } else {
31468 if (EXPECTED(Z_ISREF_P(object_ptr))) {
31469 object_ptr = Z_REFVAL_P(object_ptr);
31470 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31471 goto try_assign_dim_array;
31472 }
31473 }
31474 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
31475 zend_object *obj = Z_OBJ_P(object_ptr);
31476
31477 GC_ADDREF(obj);
31478 dim = EX_VAR(opline->op2.var);
31479 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
31480 dim = ZVAL_UNDEFINED_OP2();
31481 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31482 dim++;
31483 }
31484
31485 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31486 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
31487 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31488 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
31489 ZVAL_DEREF(value);
31490 }
31491
31492 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
31493
31494 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31495 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
31496 zend_objects_store_del(obj);
31497 }
31498 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
31499 if (IS_CV == IS_UNUSED) {
31500 zend_use_new_element_for_string();
31501 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31502 UNDEF_RESULT();
31503 } else {
31504 dim = EX_VAR(opline->op2.var);
31505 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31506 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
31507 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31508 }
31509 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
31510 if (Z_ISREF_P(orig_object_ptr)
31511 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
31512 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
31513 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31514 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31515 UNDEF_RESULT();
31516 } else {
31517 HashTable *ht = zend_new_array(8);
31518 uint8_t old_type = Z_TYPE_P(object_ptr);
31519
31520 ZVAL_ARR(object_ptr, ht);
31521 if (UNEXPECTED(old_type == IS_FALSE)) {
31522 GC_ADDREF(ht);
31523 zend_false_to_array_deprecated();
31524 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31525 zend_array_destroy(ht);
31526 goto assign_dim_error;
31527 }
31528 }
31529 goto try_assign_dim_array;
31530 }
31531 } else {
31532 zend_use_scalar_as_array();
31533 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31534 assign_dim_error:
31535 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31536 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31537 ZVAL_NULL(EX_VAR(opline->result.var));
31538 }
31539 }
31540 }
31541 if (IS_CV != IS_UNUSED) {
31542
31543 }
31544 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31545 /* assign_dim has two opcodes! */
31546 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31547 }
31548
ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31549 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31550 {
31551 USE_OPLINE
31552 zval *object_ptr, *orig_object_ptr;
31553 zval *value;
31554 zval *variable_ptr;
31555 zval *dim;
31556 zend_refcounted *garbage = NULL;
31557
31558 SAVE_OPLINE();
31559 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31560
31561 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31562 try_assign_dim_array:
31563 SEPARATE_ARRAY(object_ptr);
31564 if (IS_CV == IS_UNUSED) {
31565 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31566 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
31567 HashTable *ht = Z_ARRVAL_P(object_ptr);
31568 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
31569 GC_ADDREF(ht);
31570 }
31571 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31572 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
31573 zend_array_destroy(ht);
31574 goto assign_dim_error;
31575 }
31576 }
31577 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
31578 ZVAL_DEREF(value);
31579 }
31580 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
31581 if (UNEXPECTED(value == NULL)) {
31582 zend_cannot_add_element();
31583 goto assign_dim_error;
31584 } else if (IS_VAR == IS_CV) {
31585 if (Z_REFCOUNTED_P(value)) {
31586 Z_ADDREF_P(value);
31587 }
31588 } else if (IS_VAR == IS_VAR) {
31589 zval *free_op_data = EX_VAR((opline+1)->op1.var);
31590 if (Z_ISREF_P(free_op_data)) {
31591 if (Z_REFCOUNTED_P(value)) {
31592 Z_ADDREF_P(value);
31593 }
31594 zval_ptr_dtor_nogc(free_op_data);
31595 }
31596 } else if (IS_VAR == IS_CONST) {
31597 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
31598 Z_ADDREF_P(value);
31599 }
31600 }
31601 } else {
31602 dim = EX_VAR(opline->op2.var);
31603 if (IS_CV == IS_CONST) {
31604 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31605 } else {
31606 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31607 }
31608 if (UNEXPECTED(variable_ptr == NULL)) {
31609 goto assign_dim_error;
31610 }
31611 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31612 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
31613 }
31614 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31615 ZVAL_COPY(EX_VAR(opline->result.var), value);
31616 }
31617 if (garbage) {
31618 GC_DTOR_NO_REF(garbage);
31619 }
31620 } else {
31621 if (EXPECTED(Z_ISREF_P(object_ptr))) {
31622 object_ptr = Z_REFVAL_P(object_ptr);
31623 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31624 goto try_assign_dim_array;
31625 }
31626 }
31627 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
31628 zend_object *obj = Z_OBJ_P(object_ptr);
31629
31630 GC_ADDREF(obj);
31631 dim = EX_VAR(opline->op2.var);
31632 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
31633 dim = ZVAL_UNDEFINED_OP2();
31634 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31635 dim++;
31636 }
31637
31638 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31639 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
31640 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31641 } else if (IS_VAR & (IS_CV|IS_VAR)) {
31642 ZVAL_DEREF(value);
31643 }
31644
31645 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
31646
31647 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31648 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
31649 zend_objects_store_del(obj);
31650 }
31651 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
31652 if (IS_CV == IS_UNUSED) {
31653 zend_use_new_element_for_string();
31654 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31655 UNDEF_RESULT();
31656 } else {
31657 dim = EX_VAR(opline->op2.var);
31658 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31659 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
31660 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31661 }
31662 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
31663 if (Z_ISREF_P(orig_object_ptr)
31664 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
31665 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
31666 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31667 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31668 UNDEF_RESULT();
31669 } else {
31670 HashTable *ht = zend_new_array(8);
31671 uint8_t old_type = Z_TYPE_P(object_ptr);
31672
31673 ZVAL_ARR(object_ptr, ht);
31674 if (UNEXPECTED(old_type == IS_FALSE)) {
31675 GC_ADDREF(ht);
31676 zend_false_to_array_deprecated();
31677 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31678 zend_array_destroy(ht);
31679 goto assign_dim_error;
31680 }
31681 }
31682 goto try_assign_dim_array;
31683 }
31684 } else {
31685 zend_use_scalar_as_array();
31686 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31687 assign_dim_error:
31688 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31689 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31690 ZVAL_NULL(EX_VAR(opline->result.var));
31691 }
31692 }
31693 }
31694 if (IS_CV != IS_UNUSED) {
31695
31696 }
31697 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31698 /* assign_dim has two opcodes! */
31699 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31700 }
31701
ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31702 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31703 {
31704 USE_OPLINE
31705 zval *object_ptr, *orig_object_ptr;
31706 zval *value;
31707 zval *variable_ptr;
31708 zval *dim;
31709 zend_refcounted *garbage = NULL;
31710
31711 SAVE_OPLINE();
31712 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31713
31714 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31715 try_assign_dim_array:
31716 SEPARATE_ARRAY(object_ptr);
31717 if (IS_CV == IS_UNUSED) {
31718 value = EX_VAR((opline+1)->op1.var);
31719 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
31720 HashTable *ht = Z_ARRVAL_P(object_ptr);
31721 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
31722 GC_ADDREF(ht);
31723 }
31724 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31725 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
31726 zend_array_destroy(ht);
31727 goto assign_dim_error;
31728 }
31729 }
31730 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
31731 ZVAL_DEREF(value);
31732 }
31733 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
31734 if (UNEXPECTED(value == NULL)) {
31735 zend_cannot_add_element();
31736 goto assign_dim_error;
31737 } else if (IS_CV == IS_CV) {
31738 if (Z_REFCOUNTED_P(value)) {
31739 Z_ADDREF_P(value);
31740 }
31741 } else if (IS_CV == IS_VAR) {
31742 zval *free_op_data = EX_VAR((opline+1)->op1.var);
31743 if (Z_ISREF_P(free_op_data)) {
31744 if (Z_REFCOUNTED_P(value)) {
31745 Z_ADDREF_P(value);
31746 }
31747 zval_ptr_dtor_nogc(free_op_data);
31748 }
31749 } else if (IS_CV == IS_CONST) {
31750 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
31751 Z_ADDREF_P(value);
31752 }
31753 }
31754 } else {
31755 dim = EX_VAR(opline->op2.var);
31756 if (IS_CV == IS_CONST) {
31757 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31758 } else {
31759 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31760 }
31761 if (UNEXPECTED(variable_ptr == NULL)) {
31762 goto assign_dim_error;
31763 }
31764 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
31765 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31766 }
31767 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31768 ZVAL_COPY(EX_VAR(opline->result.var), value);
31769 }
31770 if (garbage) {
31771 GC_DTOR_NO_REF(garbage);
31772 }
31773 } else {
31774 if (EXPECTED(Z_ISREF_P(object_ptr))) {
31775 object_ptr = Z_REFVAL_P(object_ptr);
31776 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31777 goto try_assign_dim_array;
31778 }
31779 }
31780 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
31781 zend_object *obj = Z_OBJ_P(object_ptr);
31782
31783 GC_ADDREF(obj);
31784 dim = EX_VAR(opline->op2.var);
31785 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
31786 dim = ZVAL_UNDEFINED_OP2();
31787 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31788 dim++;
31789 }
31790
31791 value = EX_VAR((opline+1)->op1.var);
31792 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
31793 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31794 } else if (IS_CV & (IS_CV|IS_VAR)) {
31795 ZVAL_DEREF(value);
31796 }
31797
31798 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
31799
31800 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
31801 zend_objects_store_del(obj);
31802 }
31803 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
31804 if (IS_CV == IS_UNUSED) {
31805 zend_use_new_element_for_string();
31806
31807 UNDEF_RESULT();
31808 } else {
31809 dim = EX_VAR(opline->op2.var);
31810 value = EX_VAR((opline+1)->op1.var);
31811 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
31812
31813 }
31814 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
31815 if (Z_ISREF_P(orig_object_ptr)
31816 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
31817 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
31818 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31819
31820 UNDEF_RESULT();
31821 } else {
31822 HashTable *ht = zend_new_array(8);
31823 uint8_t old_type = Z_TYPE_P(object_ptr);
31824
31825 ZVAL_ARR(object_ptr, ht);
31826 if (UNEXPECTED(old_type == IS_FALSE)) {
31827 GC_ADDREF(ht);
31828 zend_false_to_array_deprecated();
31829 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31830 zend_array_destroy(ht);
31831 goto assign_dim_error;
31832 }
31833 }
31834 goto try_assign_dim_array;
31835 }
31836 } else {
31837 zend_use_scalar_as_array();
31838 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31839 assign_dim_error:
31840
31841 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31842 ZVAL_NULL(EX_VAR(opline->result.var));
31843 }
31844 }
31845 }
31846 if (IS_CV != IS_UNUSED) {
31847
31848 }
31849 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31850 /* assign_dim has two opcodes! */
31851 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31852 }
31853
ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31854 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31855 {
31856 USE_OPLINE
31857 zval *value;
31858 zval *variable_ptr;
31859
31860 SAVE_OPLINE();
31861 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31862 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31863
31864 if (0 || UNEXPECTED(0)) {
31865 zend_refcounted *garbage = NULL;
31866
31867 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31868 if (UNEXPECTED(0)) {
31869 ZVAL_COPY(EX_VAR(opline->result.var), value);
31870 }
31871 if (garbage) {
31872 GC_DTOR_NO_REF(garbage);
31873 }
31874 } else {
31875 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
31876 }
31877 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31878 /* zend_assign_to_variable() always takes care of op2, never free it! */
31879
31880 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31881 }
31882
ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31883 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31884 {
31885 USE_OPLINE
31886 zval *value;
31887 zval *variable_ptr;
31888
31889 SAVE_OPLINE();
31890 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31891 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31892
31893 if (0 || UNEXPECTED(1)) {
31894 zend_refcounted *garbage = NULL;
31895
31896 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31897 if (UNEXPECTED(1)) {
31898 ZVAL_COPY(EX_VAR(opline->result.var), value);
31899 }
31900 if (garbage) {
31901 GC_DTOR_NO_REF(garbage);
31902 }
31903 } else {
31904 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
31905 }
31906 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31907 /* zend_assign_to_variable() always takes care of op2, never free it! */
31908
31909 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31910 }
31911
ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31912 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31913 {
31914 USE_OPLINE
31915 zval *variable_ptr;
31916 zval *value_ptr;
31917 zend_refcounted *garbage = NULL;
31918
31919 SAVE_OPLINE();
31920 value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
31921 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31922
31923 if (IS_VAR == IS_VAR &&
31924 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
31925
31926 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
31927 variable_ptr = &EG(uninitialized_zval);
31928 } else if (IS_CV == IS_VAR &&
31929 opline->extended_value == ZEND_RETURNS_FUNCTION &&
31930 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
31931
31932 variable_ptr = zend_wrong_assign_to_variable_reference(
31933 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
31934 } else {
31935 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
31936 }
31937
31938 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31939 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
31940 }
31941
31942 if (garbage) {
31943 GC_DTOR(garbage);
31944 }
31945
31946 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31947 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31948 }
31949
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31950 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31951 {
31952 USE_OPLINE
31953 zval *property, *container, *value_ptr;
31954
31955 SAVE_OPLINE();
31956
31957 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31958 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31959
31960 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31961
31962 if (1) {
31963 if (IS_VAR == IS_UNUSED) {
31964 if (IS_CV == IS_CONST) {
31965 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31966 } else {
31967 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31968 }
31969 } else {
31970 if (IS_CV == IS_CONST) {
31971 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31972 } else {
31973 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31974 }
31975 }
31976 } else {
31977 zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31978 }
31979
31980 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31981
31982 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31983 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31984 }
31985
31986 /* 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)31987 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31988 {
31989 USE_OPLINE
31990 zval *property, *container, *value_ptr;
31991
31992 SAVE_OPLINE();
31993
31994 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31995 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31996
31997 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
31998
31999 if (1) {
32000 if (IS_VAR == IS_UNUSED) {
32001 if (IS_CV == IS_CONST) {
32002 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32003 } else {
32004 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32005 }
32006 } else {
32007 if (IS_CV == IS_CONST) {
32008 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32009 } else {
32010 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32011 }
32012 }
32013 } else {
32014 zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32015 }
32016
32017 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32018
32019
32020 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32021 }
32022
32023 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32024 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32025 {
32026 USE_OPLINE
32027 zval *function_name;
32028 zend_class_entry *ce;
32029 uint32_t call_info;
32030 zend_function *fbc;
32031 zend_execute_data *call;
32032
32033 SAVE_OPLINE();
32034
32035 if (IS_VAR == IS_CONST) {
32036 /* no function found. try a static method in class */
32037 ce = CACHED_PTR(opline->result.num);
32038 if (UNEXPECTED(ce == NULL)) {
32039 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);
32040 if (UNEXPECTED(ce == NULL)) {
32041
32042 HANDLE_EXCEPTION();
32043 }
32044 if (IS_CV != IS_CONST) {
32045 CACHE_PTR(opline->result.num, ce);
32046 }
32047 }
32048 } else if (IS_VAR == IS_UNUSED) {
32049 ce = zend_fetch_class(NULL, opline->op1.num);
32050 if (UNEXPECTED(ce == NULL)) {
32051
32052 HANDLE_EXCEPTION();
32053 }
32054 } else {
32055 ce = Z_CE_P(EX_VAR(opline->op1.var));
32056 }
32057
32058 if (IS_VAR == IS_CONST &&
32059 IS_CV == IS_CONST &&
32060 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
32061 /* nothing to do */
32062 } else if (IS_VAR != IS_CONST &&
32063 IS_CV == IS_CONST &&
32064 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
32065 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
32066 } else if (IS_CV != IS_UNUSED) {
32067 function_name = EX_VAR(opline->op2.var);
32068 if (IS_CV != IS_CONST) {
32069 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
32070 do {
32071 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
32072 function_name = Z_REFVAL_P(function_name);
32073 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
32074 break;
32075 }
32076 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
32077 ZVAL_UNDEFINED_OP2();
32078 if (UNEXPECTED(EG(exception) != NULL)) {
32079 HANDLE_EXCEPTION();
32080 }
32081 }
32082 zend_throw_error(NULL, "Method name must be a string");
32083
32084 HANDLE_EXCEPTION();
32085 } while (0);
32086 }
32087 }
32088
32089 if (ce->get_static_method) {
32090 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
32091 } else {
32092 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
32093 }
32094 if (UNEXPECTED(fbc == NULL)) {
32095 if (EXPECTED(!EG(exception))) {
32096 zend_undefined_method(ce, Z_STR_P(function_name));
32097 }
32098
32099 HANDLE_EXCEPTION();
32100 }
32101 if (IS_CV == IS_CONST &&
32102 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
32103 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
32104 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
32105 }
32106 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32107 init_func_run_time_cache(&fbc->op_array);
32108 }
32109 if (IS_CV != IS_CONST) {
32110
32111 }
32112 } else {
32113 if (UNEXPECTED(ce->constructor == NULL)) {
32114 zend_throw_error(NULL, "Cannot call constructor");
32115 HANDLE_EXCEPTION();
32116 }
32117 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
32118 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
32119 HANDLE_EXCEPTION();
32120 }
32121 fbc = ce->constructor;
32122 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32123 init_func_run_time_cache(&fbc->op_array);
32124 }
32125 }
32126
32127 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
32128 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
32129 ce = (zend_class_entry*)Z_OBJ(EX(This));
32130 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
32131 } else {
32132 zend_non_static_method_call(fbc);
32133 HANDLE_EXCEPTION();
32134 }
32135 } else {
32136 /* previous opcode is ZEND_FETCH_CLASS */
32137 if (IS_VAR == IS_UNUSED
32138 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
32139 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
32140 if (Z_TYPE(EX(This)) == IS_OBJECT) {
32141 ce = Z_OBJCE(EX(This));
32142 } else {
32143 ce = Z_CE(EX(This));
32144 }
32145 }
32146 call_info = ZEND_CALL_NESTED_FUNCTION;
32147 }
32148
32149 call = zend_vm_stack_push_call_frame(call_info,
32150 fbc, opline->extended_value, ce);
32151 call->prev_execute_data = EX(call);
32152 EX(call) = call;
32153
32154 ZEND_VM_NEXT_OPCODE();
32155 }
32156
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32157 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32158 {
32159 USE_OPLINE
32160 zval *expr_ptr, new_expr;
32161
32162 SAVE_OPLINE();
32163 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
32164 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
32165 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32166 if (Z_ISREF_P(expr_ptr)) {
32167 Z_ADDREF_P(expr_ptr);
32168 } else {
32169 ZVAL_MAKE_REF_EX(expr_ptr, 2);
32170 }
32171 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32172 } else {
32173 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32174 if (IS_VAR == IS_TMP_VAR) {
32175 /* pass */
32176 } else if (IS_VAR == IS_CONST) {
32177 Z_TRY_ADDREF_P(expr_ptr);
32178 } else if (IS_VAR == IS_CV) {
32179 ZVAL_DEREF(expr_ptr);
32180 Z_TRY_ADDREF_P(expr_ptr);
32181 } else /* if (IS_VAR == IS_VAR) */ {
32182 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
32183 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
32184
32185 expr_ptr = Z_REFVAL_P(expr_ptr);
32186 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
32187 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
32188 expr_ptr = &new_expr;
32189 efree_size(ref, sizeof(zend_reference));
32190 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
32191 Z_ADDREF_P(expr_ptr);
32192 }
32193 }
32194 }
32195 }
32196
32197 if (IS_CV != IS_UNUSED) {
32198 zval *offset = EX_VAR(opline->op2.var);
32199 zend_string *str;
32200 zend_ulong hval;
32201
32202 add_again:
32203 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
32204 str = Z_STR_P(offset);
32205 if (IS_CV != IS_CONST) {
32206 if (ZEND_HANDLE_NUMERIC(str, hval)) {
32207 goto num_index;
32208 }
32209 }
32210 str_index:
32211 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
32212 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
32213 hval = Z_LVAL_P(offset);
32214 num_index:
32215 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
32216 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
32217 offset = Z_REFVAL_P(offset);
32218 goto add_again;
32219 } else if (Z_TYPE_P(offset) == IS_NULL) {
32220 str = ZSTR_EMPTY_ALLOC();
32221 goto str_index;
32222 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
32223 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
32224 goto num_index;
32225 } else if (Z_TYPE_P(offset) == IS_FALSE) {
32226 hval = 0;
32227 goto num_index;
32228 } else if (Z_TYPE_P(offset) == IS_TRUE) {
32229 hval = 1;
32230 goto num_index;
32231 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
32232 zend_use_resource_as_offset(offset);
32233 hval = Z_RES_HANDLE_P(offset);
32234 goto num_index;
32235 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
32236 ZVAL_UNDEFINED_OP2();
32237 str = ZSTR_EMPTY_ALLOC();
32238 goto str_index;
32239 } else {
32240 zend_illegal_array_offset_access(offset);
32241 zval_ptr_dtor_nogc(expr_ptr);
32242 }
32243
32244 } else {
32245 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
32246 zend_cannot_add_element();
32247 zval_ptr_dtor_nogc(expr_ptr);
32248 }
32249 }
32250 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32251 }
32252
ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32253 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32254 {
32255 zval *array;
32256 uint32_t size;
32257 USE_OPLINE
32258
32259 array = EX_VAR(opline->result.var);
32260 if (IS_VAR != IS_UNUSED) {
32261 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
32262 ZVAL_ARR(array, zend_new_array(size));
32263 /* Explicitly initialize array as not-packed if flag is set */
32264 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
32265 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
32266 }
32267 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
32268 } else {
32269 ZVAL_ARR(array, zend_new_array(0));
32270 ZEND_VM_NEXT_OPCODE();
32271 }
32272 }
32273
ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32274 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32275 {
32276 USE_OPLINE
32277 zval *container;
32278 zval *offset;
32279 zend_ulong hval;
32280 zend_string *key;
32281
32282 SAVE_OPLINE();
32283 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32284 offset = EX_VAR(opline->op2.var);
32285
32286 do {
32287 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
32288 HashTable *ht;
32289
32290 unset_dim_array:
32291 SEPARATE_ARRAY(container);
32292 ht = Z_ARRVAL_P(container);
32293 offset_again:
32294 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
32295 key = Z_STR_P(offset);
32296 if (IS_CV != IS_CONST) {
32297 if (ZEND_HANDLE_NUMERIC(key, hval)) {
32298 goto num_index_dim;
32299 }
32300 }
32301 str_index_dim:
32302 ZEND_ASSERT(ht != &EG(symbol_table));
32303 zend_hash_del(ht, key);
32304 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
32305 hval = Z_LVAL_P(offset);
32306 num_index_dim:
32307 zend_hash_index_del(ht, hval);
32308 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
32309 offset = Z_REFVAL_P(offset);
32310 goto offset_again;
32311 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
32312 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
32313 goto num_index_dim;
32314 } else if (Z_TYPE_P(offset) == IS_NULL) {
32315 key = ZSTR_EMPTY_ALLOC();
32316 goto str_index_dim;
32317 } else if (Z_TYPE_P(offset) == IS_FALSE) {
32318 hval = 0;
32319 goto num_index_dim;
32320 } else if (Z_TYPE_P(offset) == IS_TRUE) {
32321 hval = 1;
32322 goto num_index_dim;
32323 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
32324 zend_use_resource_as_offset(offset);
32325 hval = Z_RES_HANDLE_P(offset);
32326 goto num_index_dim;
32327 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
32328 ZVAL_UNDEFINED_OP2();
32329 key = ZSTR_EMPTY_ALLOC();
32330 goto str_index_dim;
32331 } else {
32332 zend_illegal_array_offset_unset(offset);
32333 }
32334 break;
32335 } else if (Z_ISREF_P(container)) {
32336 container = Z_REFVAL_P(container);
32337 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
32338 goto unset_dim_array;
32339 }
32340 }
32341 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
32342 container = ZVAL_UNDEFINED_OP1();
32343 }
32344 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
32345 offset = ZVAL_UNDEFINED_OP2();
32346 }
32347 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
32348 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
32349 offset++;
32350 }
32351 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
32352 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
32353 zend_throw_error(NULL, "Cannot unset string offsets");
32354 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
32355 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
32356 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
32357 zend_false_to_array_deprecated();
32358 }
32359 } while (0);
32360
32361 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32362 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32363 }
32364
ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32365 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32366 {
32367 USE_OPLINE
32368 zval *container;
32369 zval *offset;
32370 zend_string *name, *tmp_name;
32371
32372 SAVE_OPLINE();
32373 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32374 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32375
32376 do {
32377 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
32378 if (Z_ISREF_P(container)) {
32379 container = Z_REFVAL_P(container);
32380 if (Z_TYPE_P(container) != IS_OBJECT) {
32381 if (IS_VAR == IS_CV
32382 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
32383 ZVAL_UNDEFINED_OP1();
32384 }
32385 break;
32386 }
32387 } else {
32388 break;
32389 }
32390 }
32391 if (IS_CV == IS_CONST) {
32392 name = Z_STR_P(offset);
32393 } else {
32394 name = zval_try_get_tmp_string(offset, &tmp_name);
32395 if (UNEXPECTED(!name)) {
32396 break;
32397 }
32398 }
32399 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
32400 if (IS_CV != IS_CONST) {
32401 zend_tmp_string_release(tmp_name);
32402 }
32403 } while (0);
32404
32405 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32406 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32407 }
32408
ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32409 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32410 {
32411 USE_OPLINE
32412
32413 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
32414
32415 SAVE_OPLINE();
32416 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
32417 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
32418 }
32419
32420 /* Destroy the previously yielded value */
32421 zval_ptr_dtor(&generator->value);
32422
32423 /* Destroy the previously yielded key */
32424 zval_ptr_dtor(&generator->key);
32425
32426 /* Set the new yielded value */
32427 if (IS_VAR != IS_UNUSED) {
32428 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
32429 /* Constants and temporary variables aren't yieldable by reference,
32430 * but we still allow them with a notice. */
32431 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
32432 zval *value;
32433
32434 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
32435
32436 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32437 ZVAL_COPY_VALUE(&generator->value, value);
32438 if (IS_VAR == IS_CONST) {
32439 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
32440 Z_ADDREF(generator->value);
32441 }
32442 }
32443 } else {
32444 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32445
32446 /* If a function call result is yielded and the function did
32447 * not return by reference we throw a notice. */
32448 do {
32449 if (IS_VAR == IS_VAR) {
32450 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
32451 if (opline->extended_value == ZEND_RETURNS_FUNCTION
32452 && !Z_ISREF_P(value_ptr)) {
32453 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
32454 ZVAL_COPY(&generator->value, value_ptr);
32455 break;
32456 }
32457 }
32458 if (Z_ISREF_P(value_ptr)) {
32459 Z_ADDREF_P(value_ptr);
32460 } else {
32461 ZVAL_MAKE_REF_EX(value_ptr, 2);
32462 }
32463 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
32464 } while (0);
32465
32466 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32467 }
32468 } else {
32469 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32470
32471 /* Consts, temporary variables and references need copying */
32472 if (IS_VAR == IS_CONST) {
32473 ZVAL_COPY_VALUE(&generator->value, value);
32474 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
32475 Z_ADDREF(generator->value);
32476 }
32477 } else if (IS_VAR == IS_TMP_VAR) {
32478 ZVAL_COPY_VALUE(&generator->value, value);
32479 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
32480 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
32481 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32482 } else {
32483 ZVAL_COPY_VALUE(&generator->value, value);
32484 if (IS_VAR == IS_CV) {
32485 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
32486 }
32487 }
32488 }
32489 } else {
32490 /* If no value was specified yield null */
32491 ZVAL_NULL(&generator->value);
32492 }
32493
32494 /* Set the new yielded key */
32495 if (IS_CV != IS_UNUSED) {
32496 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32497 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
32498 key = Z_REFVAL_P(key);
32499 }
32500 ZVAL_COPY(&generator->key, key);
32501
32502 if (Z_TYPE(generator->key) == IS_LONG
32503 && Z_LVAL(generator->key) > generator->largest_used_integer_key
32504 ) {
32505 generator->largest_used_integer_key = Z_LVAL(generator->key);
32506 }
32507 } else {
32508 /* If no key was specified we use auto-increment keys */
32509 generator->largest_used_integer_key++;
32510 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
32511 }
32512
32513 if (RETURN_VALUE_USED(opline)) {
32514 /* If the return value of yield is used set the send
32515 * target and initialize it to NULL */
32516 generator->send_target = EX_VAR(opline->result.var);
32517 ZVAL_NULL(generator->send_target);
32518 } else {
32519 generator->send_target = NULL;
32520 }
32521
32522 /* We increment to the next op, so we are at the correct position when the
32523 * generator is resumed. */
32524 ZEND_VM_INC_OPCODE();
32525
32526 /* The GOTO VM uses a local opline variable. We need to set the opline
32527 * variable in execute_data so we don't resume at an old position. */
32528 SAVE_OPLINE();
32529
32530 ZEND_VM_RETURN();
32531 }
32532
ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32533 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)
32534 {
32535 USE_OPLINE
32536 zval *array;
32537 zval *value, *variable_ptr;
32538 uint32_t value_type;
32539 HashTable *fe_ht;
32540 HashPosition pos;
32541
32542 array = EX_VAR(opline->op1.var);
32543 SAVE_OPLINE();
32544 fe_ht = Z_ARRVAL_P(array);
32545 pos = Z_FE_POS_P(array);
32546 if (HT_IS_PACKED(fe_ht)) {
32547 value = fe_ht->arPacked + pos;
32548 while (1) {
32549 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
32550 /* reached end of iteration */
32551 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
32552 ZEND_VM_CONTINUE();
32553 }
32554 value_type = Z_TYPE_INFO_P(value);
32555 ZEND_ASSERT(value_type != IS_INDIRECT);
32556 if (EXPECTED(value_type != IS_UNDEF)) {
32557 break;
32558 }
32559 pos++;
32560 value++;
32561 }
32562 Z_FE_POS_P(array) = pos + 1;
32563 if (0) {
32564 ZVAL_LONG(EX_VAR(opline->result.var), pos);
32565 }
32566 } else {
32567 Bucket *p;
32568
32569 p = fe_ht->arData + pos;
32570 while (1) {
32571 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
32572 /* reached end of iteration */
32573 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
32574 ZEND_VM_CONTINUE();
32575 }
32576 pos++;
32577 value = &p->val;
32578 value_type = Z_TYPE_INFO_P(value);
32579 ZEND_ASSERT(value_type != IS_INDIRECT);
32580 if (EXPECTED(value_type != IS_UNDEF)) {
32581 break;
32582 }
32583 p++;
32584 }
32585 Z_FE_POS_P(array) = pos;
32586 if (0) {
32587 if (!p->key) {
32588 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
32589 } else {
32590 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
32591 }
32592 }
32593 }
32594
32595 variable_ptr = EX_VAR(opline->op2.var);
32596 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32597 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32598 }
32599
32600
ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32601 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)
32602 {
32603 USE_OPLINE
32604 zval *array;
32605 zval *value, *variable_ptr;
32606 uint32_t value_type;
32607 HashTable *fe_ht;
32608 HashPosition pos;
32609
32610 array = EX_VAR(opline->op1.var);
32611 SAVE_OPLINE();
32612 fe_ht = Z_ARRVAL_P(array);
32613 pos = Z_FE_POS_P(array);
32614 if (HT_IS_PACKED(fe_ht)) {
32615 value = fe_ht->arPacked + pos;
32616 while (1) {
32617 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
32618 /* reached end of iteration */
32619 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
32620 ZEND_VM_CONTINUE();
32621 }
32622 value_type = Z_TYPE_INFO_P(value);
32623 ZEND_ASSERT(value_type != IS_INDIRECT);
32624 if (EXPECTED(value_type != IS_UNDEF)) {
32625 break;
32626 }
32627 pos++;
32628 value++;
32629 }
32630 Z_FE_POS_P(array) = pos + 1;
32631 if (1) {
32632 ZVAL_LONG(EX_VAR(opline->result.var), pos);
32633 }
32634 } else {
32635 Bucket *p;
32636
32637 p = fe_ht->arData + pos;
32638 while (1) {
32639 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
32640 /* reached end of iteration */
32641 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
32642 ZEND_VM_CONTINUE();
32643 }
32644 pos++;
32645 value = &p->val;
32646 value_type = Z_TYPE_INFO_P(value);
32647 ZEND_ASSERT(value_type != IS_INDIRECT);
32648 if (EXPECTED(value_type != IS_UNDEF)) {
32649 break;
32650 }
32651 p++;
32652 }
32653 Z_FE_POS_P(array) = pos;
32654 if (1) {
32655 if (!p->key) {
32656 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
32657 } else {
32658 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
32659 }
32660 }
32661 }
32662
32663 variable_ptr = EX_VAR(opline->op2.var);
32664 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32665 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32666 }
32667
32668
ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32669 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32670 {
32671 USE_OPLINE
32672 zval *obj;
32673 zend_object *zobj;
32674 zend_class_entry *ce, *scope;
32675 zend_function *clone;
32676 zend_object_clone_obj_t clone_call;
32677
32678 SAVE_OPLINE();
32679 obj = &EX(This);
32680
32681 do {
32682 if (IS_UNUSED == IS_CONST ||
32683 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
32684 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
32685 obj = Z_REFVAL_P(obj);
32686 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
32687 break;
32688 }
32689 }
32690 ZVAL_UNDEF(EX_VAR(opline->result.var));
32691 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
32692 ZVAL_UNDEFINED_OP1();
32693 if (UNEXPECTED(EG(exception) != NULL)) {
32694 HANDLE_EXCEPTION();
32695 }
32696 }
32697 zend_throw_error(NULL, "__clone method called on non-object");
32698
32699 HANDLE_EXCEPTION();
32700 }
32701 } while (0);
32702
32703 zobj = Z_OBJ_P(obj);
32704 ce = zobj->ce;
32705 clone = ce->clone;
32706 clone_call = zobj->handlers->clone_obj;
32707 if (UNEXPECTED(clone_call == NULL)) {
32708 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
32709
32710 ZVAL_UNDEF(EX_VAR(opline->result.var));
32711 HANDLE_EXCEPTION();
32712 }
32713
32714 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
32715 scope = EX(func)->op_array.scope;
32716 if (clone->common.scope != scope) {
32717 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
32718 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
32719 zend_wrong_clone_call(clone, scope);
32720
32721 ZVAL_UNDEF(EX_VAR(opline->result.var));
32722 HANDLE_EXCEPTION();
32723 }
32724 }
32725 }
32726
32727 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
32728
32729 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32730 }
32731
ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32732 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32733 {
32734 uint32_t fetch_type;
32735 zend_class_entry *called_scope, *scope;
32736 USE_OPLINE
32737
32738 if (IS_UNUSED != IS_UNUSED) {
32739 SAVE_OPLINE();
32740 zval *op = NULL;
32741 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
32742 ZVAL_DEREF(op);
32743 if (Z_TYPE_P(op) != IS_OBJECT) {
32744 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
32745 ZVAL_UNDEF(EX_VAR(opline->result.var));
32746
32747 HANDLE_EXCEPTION();
32748 }
32749 }
32750
32751 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
32752
32753 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32754 }
32755
32756 fetch_type = opline->op1.num;
32757 scope = EX(func)->op_array.scope;
32758 if (UNEXPECTED(scope == NULL)) {
32759 SAVE_OPLINE();
32760 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
32761 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
32762 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
32763 ZVAL_UNDEF(EX_VAR(opline->result.var));
32764 HANDLE_EXCEPTION();
32765 }
32766
32767 switch (fetch_type) {
32768 case ZEND_FETCH_CLASS_SELF:
32769 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
32770 break;
32771 case ZEND_FETCH_CLASS_PARENT:
32772 if (UNEXPECTED(scope->parent == NULL)) {
32773 SAVE_OPLINE();
32774 zend_throw_error(NULL,
32775 "Cannot use \"parent\" when current class scope has no parent");
32776 ZVAL_UNDEF(EX_VAR(opline->result.var));
32777 HANDLE_EXCEPTION();
32778 }
32779 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
32780 break;
32781 case ZEND_FETCH_CLASS_STATIC:
32782 if (Z_TYPE(EX(This)) == IS_OBJECT) {
32783 called_scope = Z_OBJCE(EX(This));
32784 } else {
32785 called_scope = Z_CE(EX(This));
32786 }
32787 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
32788 break;
32789 EMPTY_SWITCH_DEFAULT_CASE()
32790 }
32791 ZEND_VM_NEXT_OPCODE();
32792 }
32793
ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32794 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32795 {
32796 USE_OPLINE
32797 zval *object;
32798 zval *property;
32799 zval *value;
32800 zval *zptr;
32801 void **cache_slot;
32802 zend_property_info *prop_info;
32803 zend_object *zobj;
32804 zend_string *name, *tmp_name;
32805
32806 SAVE_OPLINE();
32807 object = &EX(This);
32808 property = RT_CONSTANT(opline, opline->op2);
32809
32810 do {
32811 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
32812
32813 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32814 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
32815 object = Z_REFVAL_P(object);
32816 goto assign_op_object;
32817 }
32818 if (IS_UNUSED == IS_CV
32819 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
32820 ZVAL_UNDEFINED_OP1();
32821 }
32822 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
32823 break;
32824 }
32825
32826 assign_op_object:
32827 /* here we are sure we are dealing with an object */
32828 zobj = Z_OBJ_P(object);
32829 if (IS_CONST == IS_CONST) {
32830 name = Z_STR_P(property);
32831 } else {
32832 name = zval_try_get_tmp_string(property, &tmp_name);
32833 if (UNEXPECTED(!name)) {
32834 UNDEF_RESULT();
32835 break;
32836 }
32837 }
32838 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
32839 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
32840 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
32841 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32842 ZVAL_NULL(EX_VAR(opline->result.var));
32843 }
32844 } else {
32845 zval *orig_zptr = zptr;
32846 zend_reference *ref;
32847
32848 do {
32849 if (UNEXPECTED(Z_ISREF_P(zptr))) {
32850 ref = Z_REF_P(zptr);
32851 zptr = Z_REFVAL_P(zptr);
32852 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
32853 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
32854 break;
32855 }
32856 }
32857
32858 if (IS_CONST == IS_CONST) {
32859 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
32860 } else {
32861 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
32862 }
32863 if (prop_info) {
32864 /* special case for typed properties */
32865 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
32866 } else {
32867 zend_binary_op(zptr, zptr, value OPLINE_CC);
32868 }
32869 } while (0);
32870
32871 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32872 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
32873 }
32874 }
32875 } else {
32876 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
32877 }
32878 if (IS_CONST != IS_CONST) {
32879 zend_tmp_string_release(tmp_name);
32880 }
32881 } while (0);
32882
32883 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
32884
32885
32886 /* assign_obj has two opcodes! */
32887 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32888 }
32889
32890 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32891 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32892 {
32893 USE_OPLINE
32894 zval *object;
32895 zval *property;
32896 zval *zptr;
32897 void **cache_slot;
32898 zend_property_info *prop_info;
32899 zend_object *zobj;
32900 zend_string *name, *tmp_name;
32901
32902 SAVE_OPLINE();
32903 object = &EX(This);
32904 property = RT_CONSTANT(opline, opline->op2);
32905
32906 do {
32907 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32908 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
32909 object = Z_REFVAL_P(object);
32910 goto pre_incdec_object;
32911 }
32912 if (IS_UNUSED == IS_CV
32913 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
32914 ZVAL_UNDEFINED_OP1();
32915 }
32916 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
32917 break;
32918 }
32919
32920 pre_incdec_object:
32921 /* here we are sure we are dealing with an object */
32922 zobj = Z_OBJ_P(object);
32923 if (IS_CONST == IS_CONST) {
32924 name = Z_STR_P(property);
32925 } else {
32926 name = zval_try_get_tmp_string(property, &tmp_name);
32927 if (UNEXPECTED(!name)) {
32928 UNDEF_RESULT();
32929 break;
32930 }
32931 }
32932 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
32933 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
32934 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
32935 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32936 ZVAL_NULL(EX_VAR(opline->result.var));
32937 }
32938 } else {
32939 if (IS_CONST == IS_CONST) {
32940 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
32941 } else {
32942 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
32943 }
32944 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
32945 }
32946 } else {
32947 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
32948 }
32949 if (IS_CONST != IS_CONST) {
32950 zend_tmp_string_release(tmp_name);
32951 }
32952 } while (0);
32953
32954
32955 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32956 }
32957
ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32958 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32959 {
32960 USE_OPLINE
32961 zval *object;
32962 zval *property;
32963 zval *zptr;
32964 void **cache_slot;
32965 zend_property_info *prop_info;
32966 zend_object *zobj;
32967 zend_string *name, *tmp_name;
32968
32969 SAVE_OPLINE();
32970 object = &EX(This);
32971 property = RT_CONSTANT(opline, opline->op2);
32972
32973 do {
32974 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32975 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
32976 object = Z_REFVAL_P(object);
32977 goto post_incdec_object;
32978 }
32979 if (IS_UNUSED == IS_CV
32980 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
32981 ZVAL_UNDEFINED_OP1();
32982 }
32983 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
32984 break;
32985 }
32986
32987 post_incdec_object:
32988 /* here we are sure we are dealing with an object */
32989 zobj = Z_OBJ_P(object);
32990 if (IS_CONST == IS_CONST) {
32991 name = Z_STR_P(property);
32992 } else {
32993 name = zval_try_get_tmp_string(property, &tmp_name);
32994 if (UNEXPECTED(!name)) {
32995 ZVAL_UNDEF(EX_VAR(opline->result.var));
32996 break;
32997 }
32998 }
32999 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
33000 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33001 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33002 ZVAL_NULL(EX_VAR(opline->result.var));
33003 } else {
33004 if (IS_CONST == IS_CONST) {
33005 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
33006 } else {
33007 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
33008 }
33009
33010 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
33011 }
33012 } else {
33013 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
33014 }
33015 if (IS_CONST != IS_CONST) {
33016 zend_tmp_string_release(tmp_name);
33017 }
33018 } while (0);
33019
33020
33021 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33022 }
33023
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33024 static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33025 {
33026 USE_OPLINE
33027 zval *container;
33028 void **cache_slot = NULL;
33029
33030 SAVE_OPLINE();
33031 container = &EX(This);
33032
33033 if (IS_UNUSED == IS_CONST ||
33034 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
33035 do {
33036 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
33037 container = Z_REFVAL_P(container);
33038 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33039 break;
33040 }
33041 }
33042 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33043 ZVAL_UNDEFINED_OP1();
33044 }
33045 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
33046 ZVAL_NULL(EX_VAR(opline->result.var));
33047 goto fetch_obj_r_finish;
33048 } while (0);
33049 }
33050
33051 /* here we are sure we are dealing with an object */
33052 do {
33053 zend_object *zobj = Z_OBJ_P(container);
33054 zend_string *name, *tmp_name;
33055 zval *retval;
33056
33057 if (IS_CONST == IS_CONST) {
33058 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
33059
33060 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
33061 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33062
33063 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33064 retval = OBJ_PROP(zobj, prop_offset);
33065 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
33066 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33067 goto fetch_obj_r_copy;
33068 } else {
33069 fetch_obj_r_fast_copy:
33070 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33071 ZEND_VM_NEXT_OPCODE();
33072 }
33073 }
33074 } else if (EXPECTED(zobj->properties != NULL)) {
33075 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33076 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
33077 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
33078
33079 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
33080 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
33081
33082 if (EXPECTED(p->key == name) ||
33083 (EXPECTED(p->h == ZSTR_H(name)) &&
33084 EXPECTED(p->key != NULL) &&
33085 EXPECTED(zend_string_equal_content(p->key, name)))) {
33086 retval = &p->val;
33087 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33088 goto fetch_obj_r_copy;
33089 } else {
33090 goto fetch_obj_r_fast_copy;
33091 }
33092 }
33093 }
33094 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
33095 }
33096 retval = zend_hash_find_known_hash(zobj->properties, name);
33097 if (EXPECTED(retval)) {
33098 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
33099 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
33100 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33101 goto fetch_obj_r_copy;
33102 } else {
33103 goto fetch_obj_r_fast_copy;
33104 }
33105 }
33106 }
33107 }
33108 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33109 } else {
33110 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33111 if (UNEXPECTED(!name)) {
33112 ZVAL_UNDEF(EX_VAR(opline->result.var));
33113 break;
33114 }
33115 }
33116
33117 #if ZEND_DEBUG
33118 /* For non-standard object handlers, verify a declared property type in debug builds.
33119 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
33120 zend_property_info *prop_info = NULL;
33121 if (zobj->handlers->read_property != zend_std_read_property) {
33122 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
33123 }
33124 #endif
33125 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
33126 #if ZEND_DEBUG
33127 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
33128 && ZEND_TYPE_IS_SET(prop_info->type)) {
33129 ZVAL_OPT_DEREF(retval);
33130 zend_verify_property_type(prop_info, retval, /* strict */ true);
33131 }
33132 #endif
33133
33134 if (IS_CONST != IS_CONST) {
33135 zend_tmp_string_release(tmp_name);
33136 }
33137
33138 if (retval != EX_VAR(opline->result.var)) {
33139 fetch_obj_r_copy:
33140 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33141 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
33142 zend_unwrap_reference(retval);
33143 }
33144 } while (0);
33145
33146 fetch_obj_r_finish:
33147
33148
33149 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33150 }
33151
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33152 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33153 {
33154 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33155 }
33156
ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33157 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33158 {
33159 USE_OPLINE
33160 zval *property, *container, *result;
33161
33162 SAVE_OPLINE();
33163
33164 container = &EX(This);
33165 property = RT_CONSTANT(opline, opline->op2);
33166 result = EX_VAR(opline->result.var);
33167 zend_fetch_property_address(
33168 result, container, IS_UNUSED, property, IS_CONST,
33169 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
33170 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
33171
33172 if (IS_UNUSED == IS_VAR) {
33173 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
33174 }
33175 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33176 }
33177
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33178 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33179 {
33180 USE_OPLINE
33181 zval *property, *container, *result;
33182
33183 SAVE_OPLINE();
33184 container = &EX(This);
33185 property = RT_CONSTANT(opline, opline->op2);
33186 result = EX_VAR(opline->result.var);
33187 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);
33188
33189 if (IS_UNUSED == IS_VAR) {
33190 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
33191 }
33192 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33193 }
33194
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33195 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33196 {
33197 USE_OPLINE
33198 zval *container;
33199 void **cache_slot = NULL;
33200
33201 SAVE_OPLINE();
33202 container = &EX(This);
33203
33204 if (IS_UNUSED == IS_CONST ||
33205 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
33206 do {
33207 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
33208 container = Z_REFVAL_P(container);
33209 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33210 break;
33211 }
33212 }
33213 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
33214 ZVAL_UNDEFINED_OP2();
33215 }
33216 ZVAL_NULL(EX_VAR(opline->result.var));
33217 goto fetch_obj_is_finish;
33218 } while (0);
33219 }
33220
33221 /* here we are sure we are dealing with an object */
33222 do {
33223 zend_object *zobj = Z_OBJ_P(container);
33224 zend_string *name, *tmp_name;
33225 zval *retval;
33226
33227 if (IS_CONST == IS_CONST) {
33228 cache_slot = CACHE_ADDR(opline->extended_value);
33229
33230 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
33231 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33232
33233 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33234 retval = OBJ_PROP(zobj, prop_offset);
33235 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
33236 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33237 goto fetch_obj_is_copy;
33238 } else {
33239 fetch_obj_is_fast_copy:
33240 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33241 ZEND_VM_NEXT_OPCODE();
33242 }
33243 }
33244 } else if (EXPECTED(zobj->properties != NULL)) {
33245 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33246 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
33247 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
33248
33249 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
33250 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
33251
33252 if (EXPECTED(p->key == name) ||
33253 (EXPECTED(p->h == ZSTR_H(name)) &&
33254 EXPECTED(p->key != NULL) &&
33255 EXPECTED(zend_string_equal_content(p->key, name)))) {
33256 retval = &p->val;
33257 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33258 goto fetch_obj_is_copy;
33259 } else {
33260 goto fetch_obj_is_fast_copy;
33261 }
33262 }
33263 }
33264 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
33265 }
33266 retval = zend_hash_find_known_hash(zobj->properties, name);
33267 if (EXPECTED(retval)) {
33268 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
33269 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
33270 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33271 goto fetch_obj_is_copy;
33272 } else {
33273 goto fetch_obj_is_fast_copy;
33274 }
33275 }
33276 }
33277 }
33278 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33279 } else {
33280 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33281 if (UNEXPECTED(!name)) {
33282 ZVAL_UNDEF(EX_VAR(opline->result.var));
33283 break;
33284 }
33285 }
33286
33287 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
33288
33289 if (IS_CONST != IS_CONST) {
33290 zend_tmp_string_release(tmp_name);
33291 }
33292
33293 if (retval != EX_VAR(opline->result.var)) {
33294 fetch_obj_is_copy:
33295 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33296 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
33297 zend_unwrap_reference(retval);
33298 }
33299 } while (0);
33300
33301 fetch_obj_is_finish:
33302
33303
33304 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33305 }
33306
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33307 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33308 {
33309 #if 0
33310 USE_OPLINE
33311 #endif
33312
33313 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
33314 /* Behave like FETCH_OBJ_W */
33315 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
33316 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33317 }
33318 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33319 } else {
33320 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33321 }
33322 }
33323
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33324 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33325 {
33326 USE_OPLINE
33327 zval *container, *property, *result;
33328
33329 SAVE_OPLINE();
33330 container = &EX(This);
33331 property = RT_CONSTANT(opline, opline->op2);
33332 result = EX_VAR(opline->result.var);
33333 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);
33334
33335 if (IS_UNUSED == IS_VAR) {
33336 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
33337 }
33338 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33339 }
33340
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33341 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33342 {
33343 USE_OPLINE
33344 zval *object, *value, tmp;
33345 zend_object *zobj;
33346 zend_string *name, *tmp_name;
33347 zend_refcounted *garbage = NULL;
33348
33349 SAVE_OPLINE();
33350 object = &EX(This);
33351 value = RT_CONSTANT((opline+1), (opline+1)->op1);
33352
33353 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33354 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33355 object = Z_REFVAL_P(object);
33356 goto assign_object;
33357 }
33358 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
33359 value = &EG(uninitialized_zval);
33360 goto free_and_exit_assign_obj;
33361 }
33362
33363 assign_object:
33364 zobj = Z_OBJ_P(object);
33365 if (IS_CONST == IS_CONST) {
33366 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
33367 void **cache_slot = CACHE_ADDR(opline->extended_value);
33368 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33369 zval *property_val;
33370
33371 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33372 property_val = OBJ_PROP(zobj, prop_offset);
33373 if (Z_TYPE_P(property_val) != IS_UNDEF) {
33374 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
33375
33376 if (prop_info != NULL) {
33377 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
33378 goto free_and_exit_assign_obj;
33379 } else {
33380 fast_assign_obj:
33381 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
33382 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33383 ZVAL_COPY(EX_VAR(opline->result.var), value);
33384 }
33385 goto exit_assign_obj;
33386 }
33387 }
33388 } else {
33389 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33390 if (EXPECTED(zobj->properties != NULL)) {
33391 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
33392 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
33393 GC_DELREF(zobj->properties);
33394 }
33395 zobj->properties = zend_array_dup(zobj->properties);
33396 }
33397 property_val = zend_hash_find_known_hash(zobj->properties, name);
33398 if (property_val) {
33399 goto fast_assign_obj;
33400 }
33401 }
33402
33403 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
33404 if (EXPECTED(zobj->properties == NULL)) {
33405 rebuild_object_properties(zobj);
33406 }
33407 if (IS_CONST == IS_CONST) {
33408 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
33409 Z_ADDREF_P(value);
33410 }
33411 } else if (IS_CONST != IS_TMP_VAR) {
33412 if (Z_ISREF_P(value)) {
33413 if (IS_CONST == IS_VAR) {
33414 zend_reference *ref = Z_REF_P(value);
33415 if (GC_DELREF(ref) == 0) {
33416 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
33417 efree_size(ref, sizeof(zend_reference));
33418 value = &tmp;
33419 } else {
33420 value = Z_REFVAL_P(value);
33421 Z_TRY_ADDREF_P(value);
33422 }
33423 } else {
33424 value = Z_REFVAL_P(value);
33425 Z_TRY_ADDREF_P(value);
33426 }
33427 } else if (IS_CONST == IS_CV) {
33428 Z_TRY_ADDREF_P(value);
33429 }
33430 }
33431 zend_hash_add_new(zobj->properties, name, value);
33432 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33433 ZVAL_COPY(EX_VAR(opline->result.var), value);
33434 }
33435 goto exit_assign_obj;
33436 }
33437 }
33438 }
33439 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33440 } else {
33441 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33442 if (UNEXPECTED(!name)) {
33443
33444 UNDEF_RESULT();
33445 goto exit_assign_obj;
33446 }
33447 }
33448
33449 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
33450 ZVAL_DEREF(value);
33451 }
33452
33453 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
33454
33455 if (IS_CONST != IS_CONST) {
33456 zend_tmp_string_release(tmp_name);
33457 }
33458
33459 free_and_exit_assign_obj:
33460 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
33461 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
33462 }
33463
33464 exit_assign_obj:
33465 if (garbage) {
33466 GC_DTOR_NO_REF(garbage);
33467 }
33468
33469
33470 /* assign_obj has two opcodes! */
33471 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33472 }
33473
33474 /* 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)33475 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33476 {
33477 USE_OPLINE
33478 zval *object, *value, tmp;
33479 zend_object *zobj;
33480 zend_string *name, *tmp_name;
33481 zend_refcounted *garbage = NULL;
33482
33483 SAVE_OPLINE();
33484 object = &EX(This);
33485 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
33486
33487 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33488 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33489 object = Z_REFVAL_P(object);
33490 goto assign_object;
33491 }
33492 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
33493 value = &EG(uninitialized_zval);
33494 goto free_and_exit_assign_obj;
33495 }
33496
33497 assign_object:
33498 zobj = Z_OBJ_P(object);
33499 if (IS_CONST == IS_CONST) {
33500 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
33501 void **cache_slot = CACHE_ADDR(opline->extended_value);
33502 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33503 zval *property_val;
33504
33505 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33506 property_val = OBJ_PROP(zobj, prop_offset);
33507 if (Z_TYPE_P(property_val) != IS_UNDEF) {
33508 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
33509
33510 if (prop_info != NULL) {
33511 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
33512 goto free_and_exit_assign_obj;
33513 } else {
33514 fast_assign_obj:
33515 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
33516 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33517 ZVAL_COPY(EX_VAR(opline->result.var), value);
33518 }
33519 goto exit_assign_obj;
33520 }
33521 }
33522 } else {
33523 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33524 if (EXPECTED(zobj->properties != NULL)) {
33525 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
33526 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
33527 GC_DELREF(zobj->properties);
33528 }
33529 zobj->properties = zend_array_dup(zobj->properties);
33530 }
33531 property_val = zend_hash_find_known_hash(zobj->properties, name);
33532 if (property_val) {
33533 goto fast_assign_obj;
33534 }
33535 }
33536
33537 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
33538 if (EXPECTED(zobj->properties == NULL)) {
33539 rebuild_object_properties(zobj);
33540 }
33541 if (IS_TMP_VAR == IS_CONST) {
33542 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
33543 Z_ADDREF_P(value);
33544 }
33545 } else if (IS_TMP_VAR != IS_TMP_VAR) {
33546 if (Z_ISREF_P(value)) {
33547 if (IS_TMP_VAR == IS_VAR) {
33548 zend_reference *ref = Z_REF_P(value);
33549 if (GC_DELREF(ref) == 0) {
33550 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
33551 efree_size(ref, sizeof(zend_reference));
33552 value = &tmp;
33553 } else {
33554 value = Z_REFVAL_P(value);
33555 Z_TRY_ADDREF_P(value);
33556 }
33557 } else {
33558 value = Z_REFVAL_P(value);
33559 Z_TRY_ADDREF_P(value);
33560 }
33561 } else if (IS_TMP_VAR == IS_CV) {
33562 Z_TRY_ADDREF_P(value);
33563 }
33564 }
33565 zend_hash_add_new(zobj->properties, name, value);
33566 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33567 ZVAL_COPY(EX_VAR(opline->result.var), value);
33568 }
33569 goto exit_assign_obj;
33570 }
33571 }
33572 }
33573 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33574 } else {
33575 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33576 if (UNEXPECTED(!name)) {
33577 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
33578 UNDEF_RESULT();
33579 goto exit_assign_obj;
33580 }
33581 }
33582
33583 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
33584 ZVAL_DEREF(value);
33585 }
33586
33587 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
33588
33589 if (IS_CONST != IS_CONST) {
33590 zend_tmp_string_release(tmp_name);
33591 }
33592
33593 free_and_exit_assign_obj:
33594 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
33595 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
33596 }
33597 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
33598 exit_assign_obj:
33599 if (garbage) {
33600 GC_DTOR_NO_REF(garbage);
33601 }
33602
33603
33604 /* assign_obj has two opcodes! */
33605 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33606 }
33607
33608 /* 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)33609 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33610 {
33611 USE_OPLINE
33612 zval *object, *value, tmp;
33613 zend_object *zobj;
33614 zend_string *name, *tmp_name;
33615 zend_refcounted *garbage = NULL;
33616
33617 SAVE_OPLINE();
33618 object = &EX(This);
33619 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
33620
33621 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33622 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33623 object = Z_REFVAL_P(object);
33624 goto assign_object;
33625 }
33626 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
33627 value = &EG(uninitialized_zval);
33628 goto free_and_exit_assign_obj;
33629 }
33630
33631 assign_object:
33632 zobj = Z_OBJ_P(object);
33633 if (IS_CONST == IS_CONST) {
33634 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
33635 void **cache_slot = CACHE_ADDR(opline->extended_value);
33636 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33637 zval *property_val;
33638
33639 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33640 property_val = OBJ_PROP(zobj, prop_offset);
33641 if (Z_TYPE_P(property_val) != IS_UNDEF) {
33642 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
33643
33644 if (prop_info != NULL) {
33645 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
33646 goto free_and_exit_assign_obj;
33647 } else {
33648 fast_assign_obj:
33649 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
33650 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33651 ZVAL_COPY(EX_VAR(opline->result.var), value);
33652 }
33653 goto exit_assign_obj;
33654 }
33655 }
33656 } else {
33657 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33658 if (EXPECTED(zobj->properties != NULL)) {
33659 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
33660 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
33661 GC_DELREF(zobj->properties);
33662 }
33663 zobj->properties = zend_array_dup(zobj->properties);
33664 }
33665 property_val = zend_hash_find_known_hash(zobj->properties, name);
33666 if (property_val) {
33667 goto fast_assign_obj;
33668 }
33669 }
33670
33671 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
33672 if (EXPECTED(zobj->properties == NULL)) {
33673 rebuild_object_properties(zobj);
33674 }
33675 if (IS_VAR == IS_CONST) {
33676 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
33677 Z_ADDREF_P(value);
33678 }
33679 } else if (IS_VAR != IS_TMP_VAR) {
33680 if (Z_ISREF_P(value)) {
33681 if (IS_VAR == IS_VAR) {
33682 zend_reference *ref = Z_REF_P(value);
33683 if (GC_DELREF(ref) == 0) {
33684 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
33685 efree_size(ref, sizeof(zend_reference));
33686 value = &tmp;
33687 } else {
33688 value = Z_REFVAL_P(value);
33689 Z_TRY_ADDREF_P(value);
33690 }
33691 } else {
33692 value = Z_REFVAL_P(value);
33693 Z_TRY_ADDREF_P(value);
33694 }
33695 } else if (IS_VAR == IS_CV) {
33696 Z_TRY_ADDREF_P(value);
33697 }
33698 }
33699 zend_hash_add_new(zobj->properties, name, value);
33700 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33701 ZVAL_COPY(EX_VAR(opline->result.var), value);
33702 }
33703 goto exit_assign_obj;
33704 }
33705 }
33706 }
33707 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33708 } else {
33709 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33710 if (UNEXPECTED(!name)) {
33711 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
33712 UNDEF_RESULT();
33713 goto exit_assign_obj;
33714 }
33715 }
33716
33717 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
33718 ZVAL_DEREF(value);
33719 }
33720
33721 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
33722
33723 if (IS_CONST != IS_CONST) {
33724 zend_tmp_string_release(tmp_name);
33725 }
33726
33727 free_and_exit_assign_obj:
33728 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
33729 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
33730 }
33731 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
33732 exit_assign_obj:
33733 if (garbage) {
33734 GC_DTOR_NO_REF(garbage);
33735 }
33736
33737
33738 /* assign_obj has two opcodes! */
33739 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33740 }
33741
33742 /* 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)33743 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33744 {
33745 USE_OPLINE
33746 zval *object, *value, tmp;
33747 zend_object *zobj;
33748 zend_string *name, *tmp_name;
33749 zend_refcounted *garbage = NULL;
33750
33751 SAVE_OPLINE();
33752 object = &EX(This);
33753 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
33754
33755 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33756 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33757 object = Z_REFVAL_P(object);
33758 goto assign_object;
33759 }
33760 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
33761 value = &EG(uninitialized_zval);
33762 goto free_and_exit_assign_obj;
33763 }
33764
33765 assign_object:
33766 zobj = Z_OBJ_P(object);
33767 if (IS_CONST == IS_CONST) {
33768 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
33769 void **cache_slot = CACHE_ADDR(opline->extended_value);
33770 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33771 zval *property_val;
33772
33773 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33774 property_val = OBJ_PROP(zobj, prop_offset);
33775 if (Z_TYPE_P(property_val) != IS_UNDEF) {
33776 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
33777
33778 if (prop_info != NULL) {
33779 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
33780 goto free_and_exit_assign_obj;
33781 } else {
33782 fast_assign_obj:
33783 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
33784 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33785 ZVAL_COPY(EX_VAR(opline->result.var), value);
33786 }
33787 goto exit_assign_obj;
33788 }
33789 }
33790 } else {
33791 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33792 if (EXPECTED(zobj->properties != NULL)) {
33793 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
33794 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
33795 GC_DELREF(zobj->properties);
33796 }
33797 zobj->properties = zend_array_dup(zobj->properties);
33798 }
33799 property_val = zend_hash_find_known_hash(zobj->properties, name);
33800 if (property_val) {
33801 goto fast_assign_obj;
33802 }
33803 }
33804
33805 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
33806 if (EXPECTED(zobj->properties == NULL)) {
33807 rebuild_object_properties(zobj);
33808 }
33809 if (IS_CV == IS_CONST) {
33810 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
33811 Z_ADDREF_P(value);
33812 }
33813 } else if (IS_CV != IS_TMP_VAR) {
33814 if (Z_ISREF_P(value)) {
33815 if (IS_CV == IS_VAR) {
33816 zend_reference *ref = Z_REF_P(value);
33817 if (GC_DELREF(ref) == 0) {
33818 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
33819 efree_size(ref, sizeof(zend_reference));
33820 value = &tmp;
33821 } else {
33822 value = Z_REFVAL_P(value);
33823 Z_TRY_ADDREF_P(value);
33824 }
33825 } else {
33826 value = Z_REFVAL_P(value);
33827 Z_TRY_ADDREF_P(value);
33828 }
33829 } else if (IS_CV == IS_CV) {
33830 Z_TRY_ADDREF_P(value);
33831 }
33832 }
33833 zend_hash_add_new(zobj->properties, name, value);
33834 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33835 ZVAL_COPY(EX_VAR(opline->result.var), value);
33836 }
33837 goto exit_assign_obj;
33838 }
33839 }
33840 }
33841 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33842 } else {
33843 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33844 if (UNEXPECTED(!name)) {
33845
33846 UNDEF_RESULT();
33847 goto exit_assign_obj;
33848 }
33849 }
33850
33851 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
33852 ZVAL_DEREF(value);
33853 }
33854
33855 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
33856
33857 if (IS_CONST != IS_CONST) {
33858 zend_tmp_string_release(tmp_name);
33859 }
33860
33861 free_and_exit_assign_obj:
33862 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
33863 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
33864 }
33865
33866 exit_assign_obj:
33867 if (garbage) {
33868 GC_DTOR_NO_REF(garbage);
33869 }
33870
33871
33872 /* assign_obj has two opcodes! */
33873 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33874 }
33875
33876 /* 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)33877 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33878 {
33879 USE_OPLINE
33880 zval *property, *container, *value_ptr;
33881
33882 SAVE_OPLINE();
33883
33884 container = &EX(This);
33885 property = RT_CONSTANT(opline, opline->op2);
33886
33887 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
33888
33889 if (1) {
33890 if (IS_UNUSED == IS_UNUSED) {
33891 if (IS_CONST == IS_CONST) {
33892 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33893 } else {
33894 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33895 }
33896 } else {
33897 if (IS_CONST == IS_CONST) {
33898 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33899 } else {
33900 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33901 }
33902 }
33903 } else {
33904 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33905 }
33906
33907
33908 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
33909 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33910 }
33911
33912 /* 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)33913 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33914 {
33915 USE_OPLINE
33916 zval *property, *container, *value_ptr;
33917
33918 SAVE_OPLINE();
33919
33920 container = &EX(This);
33921 property = RT_CONSTANT(opline, opline->op2);
33922
33923 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
33924
33925 if (1) {
33926 if (IS_UNUSED == IS_UNUSED) {
33927 if (IS_CONST == IS_CONST) {
33928 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33929 } else {
33930 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33931 }
33932 } else {
33933 if (IS_CONST == IS_CONST) {
33934 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33935 } else {
33936 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33937 }
33938 }
33939 } else {
33940 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33941 }
33942
33943
33944
33945 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33946 }
33947
33948 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33949 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33950 {
33951 USE_OPLINE
33952 zend_string **rope;
33953 zval *var;
33954
33955 /* Compiler allocates the necessary number of zval slots to keep the rope */
33956 rope = (zend_string**)EX_VAR(opline->result.var);
33957 if (IS_CONST == IS_CONST) {
33958 var = RT_CONSTANT(opline, opline->op2);
33959 rope[0] = Z_STR_P(var);
33960 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
33961 Z_ADDREF_P(var);
33962 }
33963 } else {
33964 var = RT_CONSTANT(opline, opline->op2);
33965 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
33966 if (IS_CONST == IS_CV) {
33967 rope[0] = zend_string_copy(Z_STR_P(var));
33968 } else {
33969 rope[0] = Z_STR_P(var);
33970 }
33971 } else {
33972 SAVE_OPLINE();
33973 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
33974 ZVAL_UNDEFINED_OP2();
33975 }
33976 rope[0] = zval_get_string_func(var);
33977
33978 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33979 }
33980 }
33981 ZEND_VM_NEXT_OPCODE();
33982 }
33983
ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33984 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33985 {
33986 zval *class_name;
33987 USE_OPLINE
33988
33989 SAVE_OPLINE();
33990 if (IS_CONST == IS_UNUSED) {
33991 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
33992 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33993 } else if (IS_CONST == IS_CONST) {
33994 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
33995
33996 if (UNEXPECTED(ce == NULL)) {
33997 class_name = RT_CONSTANT(opline, opline->op2);
33998 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
33999 CACHE_PTR(opline->extended_value, ce);
34000 }
34001 Z_CE_P(EX_VAR(opline->result.var)) = ce;
34002 } else {
34003 class_name = RT_CONSTANT(opline, opline->op2);
34004 try_class_name:
34005 if (Z_TYPE_P(class_name) == IS_OBJECT) {
34006 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
34007 } else if (Z_TYPE_P(class_name) == IS_STRING) {
34008 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
34009 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
34010 class_name = Z_REFVAL_P(class_name);
34011 goto try_class_name;
34012 } else {
34013 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
34014 ZVAL_UNDEFINED_OP2();
34015 if (UNEXPECTED(EG(exception) != NULL)) {
34016 HANDLE_EXCEPTION();
34017 }
34018 }
34019 zend_throw_error(NULL, "Class name must be a valid object or a string");
34020 }
34021 }
34022
34023 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34024 }
34025
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34026 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34027 {
34028 USE_OPLINE
34029 zval *function_name;
34030 zval *object;
34031 zend_function *fbc;
34032 zend_class_entry *called_scope;
34033 zend_object *obj;
34034 zend_execute_data *call;
34035 uint32_t call_info;
34036
34037 SAVE_OPLINE();
34038
34039 object = &EX(This);
34040
34041 if (IS_CONST != IS_CONST) {
34042 function_name = RT_CONSTANT(opline, opline->op2);
34043 }
34044
34045 if (IS_CONST != IS_CONST &&
34046 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
34047 do {
34048 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
34049 function_name = Z_REFVAL_P(function_name);
34050 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
34051 break;
34052 }
34053 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
34054 ZVAL_UNDEFINED_OP2();
34055 if (UNEXPECTED(EG(exception) != NULL)) {
34056
34057 HANDLE_EXCEPTION();
34058 }
34059 }
34060 zend_throw_error(NULL, "Method name must be a string");
34061
34062
34063 HANDLE_EXCEPTION();
34064 } while (0);
34065 }
34066
34067 if (IS_UNUSED == IS_UNUSED) {
34068 obj = Z_OBJ_P(object);
34069 } else {
34070 do {
34071 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
34072 obj = Z_OBJ_P(object);
34073 } else {
34074 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
34075 zend_reference *ref = Z_REF_P(object);
34076
34077 object = &ref->val;
34078 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
34079 obj = Z_OBJ_P(object);
34080 if (IS_UNUSED & IS_VAR) {
34081 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
34082 efree_size(ref, sizeof(zend_reference));
34083 } else {
34084 Z_ADDREF_P(object);
34085 }
34086 }
34087 break;
34088 }
34089 }
34090 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
34091 object = ZVAL_UNDEFINED_OP1();
34092 if (UNEXPECTED(EG(exception) != NULL)) {
34093 if (IS_CONST != IS_CONST) {
34094
34095 }
34096 HANDLE_EXCEPTION();
34097 }
34098 }
34099 if (IS_CONST == IS_CONST) {
34100 function_name = RT_CONSTANT(opline, opline->op2);
34101 }
34102 zend_invalid_method_call(object, function_name);
34103
34104
34105 HANDLE_EXCEPTION();
34106 }
34107 } while (0);
34108 }
34109
34110 called_scope = obj->ce;
34111
34112 if (IS_CONST == IS_CONST &&
34113 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
34114 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
34115 } else {
34116 zend_object *orig_obj = obj;
34117
34118 if (IS_CONST == IS_CONST) {
34119 function_name = RT_CONSTANT(opline, opline->op2);
34120 }
34121
34122 /* First, locate the function. */
34123 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
34124 if (UNEXPECTED(fbc == NULL)) {
34125 if (EXPECTED(!EG(exception))) {
34126 zend_undefined_method(obj->ce, Z_STR_P(function_name));
34127 }
34128
34129 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
34130 zend_objects_store_del(orig_obj);
34131 }
34132 HANDLE_EXCEPTION();
34133 }
34134 if (IS_CONST == IS_CONST &&
34135 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
34136 EXPECTED(obj == orig_obj)) {
34137 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
34138 }
34139 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
34140 GC_ADDREF(obj); /* For $this pointer */
34141 if (GC_DELREF(orig_obj) == 0) {
34142 zend_objects_store_del(orig_obj);
34143 }
34144 }
34145 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
34146 init_func_run_time_cache(&fbc->op_array);
34147 }
34148 }
34149
34150 if (IS_CONST != IS_CONST) {
34151
34152 }
34153
34154 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
34155 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
34156 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
34157 zend_objects_store_del(obj);
34158 if (UNEXPECTED(EG(exception))) {
34159 HANDLE_EXCEPTION();
34160 }
34161 }
34162 /* call static method */
34163 obj = (zend_object*)called_scope;
34164 call_info = ZEND_CALL_NESTED_FUNCTION;
34165 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
34166 if (IS_UNUSED == IS_CV) {
34167 GC_ADDREF(obj); /* For $this pointer */
34168 }
34169 /* CV may be changed indirectly (e.g. when it's a reference) */
34170 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
34171 }
34172
34173 call = zend_vm_stack_push_call_frame(call_info,
34174 fbc, opline->extended_value, obj);
34175 call->prev_execute_data = EX(call);
34176 EX(call) = call;
34177
34178 ZEND_VM_NEXT_OPCODE();
34179 }
34180
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34181 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34182 {
34183 USE_OPLINE
34184 zval *function_name;
34185 zend_class_entry *ce;
34186 uint32_t call_info;
34187 zend_function *fbc;
34188 zend_execute_data *call;
34189
34190 SAVE_OPLINE();
34191
34192 if (IS_UNUSED == IS_CONST) {
34193 /* no function found. try a static method in class */
34194 ce = CACHED_PTR(opline->result.num);
34195 if (UNEXPECTED(ce == NULL)) {
34196 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);
34197 if (UNEXPECTED(ce == NULL)) {
34198
34199 HANDLE_EXCEPTION();
34200 }
34201 if (IS_CONST != IS_CONST) {
34202 CACHE_PTR(opline->result.num, ce);
34203 }
34204 }
34205 } else if (IS_UNUSED == IS_UNUSED) {
34206 ce = zend_fetch_class(NULL, opline->op1.num);
34207 if (UNEXPECTED(ce == NULL)) {
34208
34209 HANDLE_EXCEPTION();
34210 }
34211 } else {
34212 ce = Z_CE_P(EX_VAR(opline->op1.var));
34213 }
34214
34215 if (IS_UNUSED == IS_CONST &&
34216 IS_CONST == IS_CONST &&
34217 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
34218 /* nothing to do */
34219 } else if (IS_UNUSED != IS_CONST &&
34220 IS_CONST == IS_CONST &&
34221 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
34222 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
34223 } else if (IS_CONST != IS_UNUSED) {
34224 function_name = RT_CONSTANT(opline, opline->op2);
34225 if (IS_CONST != IS_CONST) {
34226 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
34227 do {
34228 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
34229 function_name = Z_REFVAL_P(function_name);
34230 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
34231 break;
34232 }
34233 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
34234 ZVAL_UNDEFINED_OP2();
34235 if (UNEXPECTED(EG(exception) != NULL)) {
34236 HANDLE_EXCEPTION();
34237 }
34238 }
34239 zend_throw_error(NULL, "Method name must be a string");
34240
34241 HANDLE_EXCEPTION();
34242 } while (0);
34243 }
34244 }
34245
34246 if (ce->get_static_method) {
34247 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
34248 } else {
34249 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
34250 }
34251 if (UNEXPECTED(fbc == NULL)) {
34252 if (EXPECTED(!EG(exception))) {
34253 zend_undefined_method(ce, Z_STR_P(function_name));
34254 }
34255
34256 HANDLE_EXCEPTION();
34257 }
34258 if (IS_CONST == IS_CONST &&
34259 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
34260 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
34261 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
34262 }
34263 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
34264 init_func_run_time_cache(&fbc->op_array);
34265 }
34266 if (IS_CONST != IS_CONST) {
34267
34268 }
34269 } else {
34270 if (UNEXPECTED(ce->constructor == NULL)) {
34271 zend_throw_error(NULL, "Cannot call constructor");
34272 HANDLE_EXCEPTION();
34273 }
34274 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
34275 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
34276 HANDLE_EXCEPTION();
34277 }
34278 fbc = ce->constructor;
34279 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
34280 init_func_run_time_cache(&fbc->op_array);
34281 }
34282 }
34283
34284 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
34285 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
34286 ce = (zend_class_entry*)Z_OBJ(EX(This));
34287 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
34288 } else {
34289 zend_non_static_method_call(fbc);
34290 HANDLE_EXCEPTION();
34291 }
34292 } else {
34293 /* previous opcode is ZEND_FETCH_CLASS */
34294 if (IS_UNUSED == IS_UNUSED
34295 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
34296 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
34297 if (Z_TYPE(EX(This)) == IS_OBJECT) {
34298 ce = Z_OBJCE(EX(This));
34299 } else {
34300 ce = Z_CE(EX(This));
34301 }
34302 }
34303 call_info = ZEND_CALL_NESTED_FUNCTION;
34304 }
34305
34306 call = zend_vm_stack_push_call_frame(call_info,
34307 fbc, opline->extended_value, ce);
34308 call->prev_execute_data = EX(call);
34309 EX(call) = call;
34310
34311 ZEND_VM_NEXT_OPCODE();
34312 }
34313
ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34314 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34315 {
34316 USE_OPLINE
34317 uint32_t arg_num;
34318
34319 if (IS_CONST == IS_CONST) {
34320 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34321 arg_num = zend_get_arg_offset_by_name(
34322 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
34323 if (UNEXPECTED(arg_num == 0)) {
34324 /* Treat this as a by-value argument, and throw an error during SEND. */
34325 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
34326 ZEND_VM_NEXT_OPCODE();
34327 }
34328 } else {
34329 arg_num = opline->op2.num;
34330 }
34331
34332 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
34333 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
34334 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
34335 } else {
34336 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
34337 }
34338 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
34339 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
34340 } else {
34341 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
34342 }
34343 ZEND_VM_NEXT_OPCODE();
34344 }
34345
ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34346 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34347 {
34348 USE_OPLINE
34349 zend_constant *c;
34350
34351 c = CACHED_PTR(opline->extended_value);
34352 if (EXPECTED(c != NULL) && EXPECTED(!IS_SPECIAL_CACHE_VAL(c))) {
34353 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), &c->value);
34354 ZEND_VM_NEXT_OPCODE();
34355 }
34356
34357 SAVE_OPLINE();
34358 zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num OPLINE_CC EXECUTE_DATA_CC);
34359 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34360 }
34361
ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34362 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34363 {
34364 zend_class_entry *ce, *scope;
34365 zend_class_constant *c;
34366 zval *value, *zv, *constant_zv;
34367 zend_string *constant_name;
34368 USE_OPLINE
34369
34370 SAVE_OPLINE();
34371
34372 do {
34373 if (IS_UNUSED == IS_CONST && IS_CONST == IS_CONST) {
34374 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
34375 value = CACHED_PTR(opline->extended_value + sizeof(void*));
34376 break;
34377 }
34378 }
34379 if (IS_UNUSED == IS_CONST) {
34380 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
34381 ce = CACHED_PTR(opline->extended_value);
34382 } else {
34383 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);
34384 if (UNEXPECTED(ce == NULL)) {
34385 ZVAL_UNDEF(EX_VAR(opline->result.var));
34386
34387 HANDLE_EXCEPTION();
34388 }
34389 CACHE_PTR(opline->extended_value, ce);
34390 }
34391 } else if (IS_UNUSED == IS_UNUSED) {
34392 ce = zend_fetch_class(NULL, opline->op1.num);
34393 if (UNEXPECTED(ce == NULL)) {
34394 ZVAL_UNDEF(EX_VAR(opline->result.var));
34395
34396 HANDLE_EXCEPTION();
34397 }
34398 } else {
34399 ce = Z_CE_P(EX_VAR(opline->op1.var));
34400 }
34401 if (IS_UNUSED != IS_CONST
34402 && IS_CONST == IS_CONST
34403 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
34404 value = CACHED_PTR(opline->extended_value + sizeof(void*));
34405 break;
34406 }
34407
34408 constant_zv = RT_CONSTANT(opline, opline->op2);
34409 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
34410 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
34411 ZVAL_UNDEF(EX_VAR(opline->result.var));
34412
34413 HANDLE_EXCEPTION();
34414 }
34415 constant_name = Z_STR_P(constant_zv);
34416 /* Magic 'class' for constant OP2 is caught at compile-time */
34417 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
34418 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
34419
34420 ZEND_VM_NEXT_OPCODE();
34421 }
34422 zv = IS_CONST == IS_CONST
34423 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
34424 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
34425
34426 if (EXPECTED(zv != NULL)) {
34427 c = Z_PTR_P(zv);
34428 scope = EX(func)->op_array.scope;
34429 if (!zend_verify_const_access(c, scope)) {
34430 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));
34431 ZVAL_UNDEF(EX_VAR(opline->result.var));
34432
34433 HANDLE_EXCEPTION();
34434 }
34435
34436 if (ce->ce_flags & ZEND_ACC_TRAIT) {
34437 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34438 ZVAL_UNDEF(EX_VAR(opline->result.var));
34439
34440 HANDLE_EXCEPTION();
34441 }
34442
34443 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
34444 if (UNEXPECTED(is_constant_deprecated)) {
34445 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34446
34447 if (EG(exception)) {
34448 ZVAL_UNDEF(EX_VAR(opline->result.var));
34449
34450 HANDLE_EXCEPTION();
34451 }
34452 }
34453
34454 value = &c->value;
34455 // Enums require loading of all class constants to build the backed enum table
34456 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)) {
34457 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
34458 ZVAL_UNDEF(EX_VAR(opline->result.var));
34459
34460 HANDLE_EXCEPTION();
34461 }
34462 }
34463 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
34464 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
34465 ZVAL_UNDEF(EX_VAR(opline->result.var));
34466
34467 HANDLE_EXCEPTION();
34468 }
34469 }
34470 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
34471 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
34472 }
34473 } else {
34474 zend_throw_error(NULL, "Undefined constant %s::%s",
34475 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34476 ZVAL_UNDEF(EX_VAR(opline->result.var));
34477
34478 HANDLE_EXCEPTION();
34479 }
34480 } while (0);
34481
34482 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
34483
34484 ZEND_VM_NEXT_OPCODE();
34485 }
34486
ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34487 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34488 {
34489 zval *array;
34490 uint32_t size;
34491 USE_OPLINE
34492
34493 array = EX_VAR(opline->result.var);
34494 if (IS_UNUSED != IS_UNUSED) {
34495 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
34496 ZVAL_ARR(array, zend_new_array(size));
34497 /* Explicitly initialize array as not-packed if flag is set */
34498 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
34499 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
34500 }
34501 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34502 } else {
34503 ZVAL_ARR(array, zend_new_array(0));
34504 ZEND_VM_NEXT_OPCODE();
34505 }
34506 }
34507
ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34508 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34509 {
34510 USE_OPLINE
34511 zval *container;
34512 zval *offset;
34513 zend_string *name, *tmp_name;
34514
34515 SAVE_OPLINE();
34516 container = &EX(This);
34517 offset = RT_CONSTANT(opline, opline->op2);
34518
34519 do {
34520 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
34521 if (Z_ISREF_P(container)) {
34522 container = Z_REFVAL_P(container);
34523 if (Z_TYPE_P(container) != IS_OBJECT) {
34524 if (IS_UNUSED == IS_CV
34525 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
34526 ZVAL_UNDEFINED_OP1();
34527 }
34528 break;
34529 }
34530 } else {
34531 break;
34532 }
34533 }
34534 if (IS_CONST == IS_CONST) {
34535 name = Z_STR_P(offset);
34536 } else {
34537 name = zval_try_get_tmp_string(offset, &tmp_name);
34538 if (UNEXPECTED(!name)) {
34539 break;
34540 }
34541 }
34542 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
34543 if (IS_CONST != IS_CONST) {
34544 zend_tmp_string_release(tmp_name);
34545 }
34546 } while (0);
34547
34548
34549 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34550 }
34551
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34552 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34553 {
34554 USE_OPLINE
34555 zval *container;
34556 int result;
34557 zval *offset;
34558 zend_string *name, *tmp_name;
34559
34560 SAVE_OPLINE();
34561 container = &EX(This);
34562 offset = RT_CONSTANT(opline, opline->op2);
34563
34564 if (IS_UNUSED == IS_CONST ||
34565 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
34566 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
34567 container = Z_REFVAL_P(container);
34568 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
34569 result = (opline->extended_value & ZEND_ISEMPTY);
34570 goto isset_object_finish;
34571 }
34572 } else {
34573 result = (opline->extended_value & ZEND_ISEMPTY);
34574 goto isset_object_finish;
34575 }
34576 }
34577
34578 if (IS_CONST == IS_CONST) {
34579 name = Z_STR_P(offset);
34580 } else {
34581 name = zval_try_get_tmp_string(offset, &tmp_name);
34582 if (UNEXPECTED(!name)) {
34583 result = 0;
34584 goto isset_object_finish;
34585 }
34586 }
34587
34588 result =
34589 (opline->extended_value & ZEND_ISEMPTY) ^
34590 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));
34591
34592 if (IS_CONST != IS_CONST) {
34593 zend_tmp_string_release(tmp_name);
34594 }
34595
34596 isset_object_finish:
34597
34598
34599 ZEND_VM_SMART_BRANCH(result, 1);
34600 }
34601
ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34602 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34603 {
34604 USE_OPLINE
34605
34606 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
34607
34608 SAVE_OPLINE();
34609 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
34610 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34611 }
34612
34613 /* Destroy the previously yielded value */
34614 zval_ptr_dtor(&generator->value);
34615
34616 /* Destroy the previously yielded key */
34617 zval_ptr_dtor(&generator->key);
34618
34619 /* Set the new yielded value */
34620 if (IS_UNUSED != IS_UNUSED) {
34621 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
34622 /* Constants and temporary variables aren't yieldable by reference,
34623 * but we still allow them with a notice. */
34624 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
34625 zval *value;
34626
34627 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
34628
34629 value = NULL;
34630 ZVAL_COPY_VALUE(&generator->value, value);
34631 if (IS_UNUSED == IS_CONST) {
34632 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
34633 Z_ADDREF(generator->value);
34634 }
34635 }
34636 } else {
34637 zval *value_ptr = NULL;
34638
34639 /* If a function call result is yielded and the function did
34640 * not return by reference we throw a notice. */
34641 do {
34642 if (IS_UNUSED == IS_VAR) {
34643 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
34644 if (opline->extended_value == ZEND_RETURNS_FUNCTION
34645 && !Z_ISREF_P(value_ptr)) {
34646 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
34647 ZVAL_COPY(&generator->value, value_ptr);
34648 break;
34649 }
34650 }
34651 if (Z_ISREF_P(value_ptr)) {
34652 Z_ADDREF_P(value_ptr);
34653 } else {
34654 ZVAL_MAKE_REF_EX(value_ptr, 2);
34655 }
34656 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
34657 } while (0);
34658
34659 }
34660 } else {
34661 zval *value = NULL;
34662
34663 /* Consts, temporary variables and references need copying */
34664 if (IS_UNUSED == IS_CONST) {
34665 ZVAL_COPY_VALUE(&generator->value, value);
34666 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
34667 Z_ADDREF(generator->value);
34668 }
34669 } else if (IS_UNUSED == IS_TMP_VAR) {
34670 ZVAL_COPY_VALUE(&generator->value, value);
34671 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
34672 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
34673
34674 } else {
34675 ZVAL_COPY_VALUE(&generator->value, value);
34676 if (IS_UNUSED == IS_CV) {
34677 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
34678 }
34679 }
34680 }
34681 } else {
34682 /* If no value was specified yield null */
34683 ZVAL_NULL(&generator->value);
34684 }
34685
34686 /* Set the new yielded key */
34687 if (IS_CONST != IS_UNUSED) {
34688 zval *key = RT_CONSTANT(opline, opline->op2);
34689 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
34690 key = Z_REFVAL_P(key);
34691 }
34692 ZVAL_COPY(&generator->key, key);
34693
34694 if (Z_TYPE(generator->key) == IS_LONG
34695 && Z_LVAL(generator->key) > generator->largest_used_integer_key
34696 ) {
34697 generator->largest_used_integer_key = Z_LVAL(generator->key);
34698 }
34699 } else {
34700 /* If no key was specified we use auto-increment keys */
34701 generator->largest_used_integer_key++;
34702 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
34703 }
34704
34705 if (RETURN_VALUE_USED(opline)) {
34706 /* If the return value of yield is used set the send
34707 * target and initialize it to NULL */
34708 generator->send_target = EX_VAR(opline->result.var);
34709 ZVAL_NULL(generator->send_target);
34710 } else {
34711 generator->send_target = NULL;
34712 }
34713
34714 /* We increment to the next op, so we are at the correct position when the
34715 * generator is resumed. */
34716 ZEND_VM_INC_OPCODE();
34717
34718 /* The GOTO VM uses a local opline variable. We need to set the opline
34719 * variable in execute_data so we don't resume at an old position. */
34720 SAVE_OPLINE();
34721
34722 ZEND_VM_RETURN();
34723 }
34724
ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34725 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34726 {
34727 zend_class_entry *ce, *scope;
34728 zend_class_constant *c;
34729 zval *value, *zv, *constant_zv;
34730 zend_string *constant_name;
34731 USE_OPLINE
34732
34733 SAVE_OPLINE();
34734
34735 do {
34736 if (IS_UNUSED == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
34737 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
34738 value = CACHED_PTR(opline->extended_value + sizeof(void*));
34739 break;
34740 }
34741 }
34742 if (IS_UNUSED == IS_CONST) {
34743 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
34744 ce = CACHED_PTR(opline->extended_value);
34745 } else {
34746 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);
34747 if (UNEXPECTED(ce == NULL)) {
34748 ZVAL_UNDEF(EX_VAR(opline->result.var));
34749 FREE_OP(opline->op2_type, opline->op2.var);
34750 HANDLE_EXCEPTION();
34751 }
34752 CACHE_PTR(opline->extended_value, ce);
34753 }
34754 } else if (IS_UNUSED == IS_UNUSED) {
34755 ce = zend_fetch_class(NULL, opline->op1.num);
34756 if (UNEXPECTED(ce == NULL)) {
34757 ZVAL_UNDEF(EX_VAR(opline->result.var));
34758 FREE_OP(opline->op2_type, opline->op2.var);
34759 HANDLE_EXCEPTION();
34760 }
34761 } else {
34762 ce = Z_CE_P(EX_VAR(opline->op1.var));
34763 }
34764 if (IS_UNUSED != IS_CONST
34765 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
34766 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
34767 value = CACHED_PTR(opline->extended_value + sizeof(void*));
34768 break;
34769 }
34770
34771 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
34772 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
34773 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
34774 ZVAL_UNDEF(EX_VAR(opline->result.var));
34775 FREE_OP(opline->op2_type, opline->op2.var);
34776 HANDLE_EXCEPTION();
34777 }
34778 constant_name = Z_STR_P(constant_zv);
34779 /* Magic 'class' for constant OP2 is caught at compile-time */
34780 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
34781 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
34782 FREE_OP(opline->op2_type, opline->op2.var);
34783 ZEND_VM_NEXT_OPCODE();
34784 }
34785 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
34786 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
34787 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
34788
34789 if (EXPECTED(zv != NULL)) {
34790 c = Z_PTR_P(zv);
34791 scope = EX(func)->op_array.scope;
34792 if (!zend_verify_const_access(c, scope)) {
34793 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));
34794 ZVAL_UNDEF(EX_VAR(opline->result.var));
34795 FREE_OP(opline->op2_type, opline->op2.var);
34796 HANDLE_EXCEPTION();
34797 }
34798
34799 if (ce->ce_flags & ZEND_ACC_TRAIT) {
34800 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34801 ZVAL_UNDEF(EX_VAR(opline->result.var));
34802 FREE_OP(opline->op2_type, opline->op2.var);
34803 HANDLE_EXCEPTION();
34804 }
34805
34806 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
34807 if (UNEXPECTED(is_constant_deprecated)) {
34808 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34809
34810 if (EG(exception)) {
34811 ZVAL_UNDEF(EX_VAR(opline->result.var));
34812 FREE_OP(opline->op2_type, opline->op2.var);
34813 HANDLE_EXCEPTION();
34814 }
34815 }
34816
34817 value = &c->value;
34818 // Enums require loading of all class constants to build the backed enum table
34819 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)) {
34820 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
34821 ZVAL_UNDEF(EX_VAR(opline->result.var));
34822 FREE_OP(opline->op2_type, opline->op2.var);
34823 HANDLE_EXCEPTION();
34824 }
34825 }
34826 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
34827 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
34828 ZVAL_UNDEF(EX_VAR(opline->result.var));
34829 FREE_OP(opline->op2_type, opline->op2.var);
34830 HANDLE_EXCEPTION();
34831 }
34832 }
34833 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
34834 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
34835 }
34836 } else {
34837 zend_throw_error(NULL, "Undefined constant %s::%s",
34838 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34839 ZVAL_UNDEF(EX_VAR(opline->result.var));
34840 FREE_OP(opline->op2_type, opline->op2.var);
34841 HANDLE_EXCEPTION();
34842 }
34843 } while (0);
34844
34845 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
34846
34847 FREE_OP(opline->op2_type, opline->op2.var);
34848 ZEND_VM_NEXT_OPCODE();
34849 }
34850
ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34851 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34852 {
34853 USE_OPLINE
34854 zval *object;
34855 zval *property;
34856 zval *value;
34857 zval *zptr;
34858 void **cache_slot;
34859 zend_property_info *prop_info;
34860 zend_object *zobj;
34861 zend_string *name, *tmp_name;
34862
34863 SAVE_OPLINE();
34864 object = &EX(This);
34865 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
34866
34867 do {
34868 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
34869
34870 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34871 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34872 object = Z_REFVAL_P(object);
34873 goto assign_op_object;
34874 }
34875 if (IS_UNUSED == IS_CV
34876 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
34877 ZVAL_UNDEFINED_OP1();
34878 }
34879 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
34880 break;
34881 }
34882
34883 assign_op_object:
34884 /* here we are sure we are dealing with an object */
34885 zobj = Z_OBJ_P(object);
34886 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
34887 name = Z_STR_P(property);
34888 } else {
34889 name = zval_try_get_tmp_string(property, &tmp_name);
34890 if (UNEXPECTED(!name)) {
34891 UNDEF_RESULT();
34892 break;
34893 }
34894 }
34895 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
34896 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
34897 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
34898 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34899 ZVAL_NULL(EX_VAR(opline->result.var));
34900 }
34901 } else {
34902 zval *orig_zptr = zptr;
34903 zend_reference *ref;
34904
34905 do {
34906 if (UNEXPECTED(Z_ISREF_P(zptr))) {
34907 ref = Z_REF_P(zptr);
34908 zptr = Z_REFVAL_P(zptr);
34909 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
34910 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
34911 break;
34912 }
34913 }
34914
34915 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
34916 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
34917 } else {
34918 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
34919 }
34920 if (prop_info) {
34921 /* special case for typed properties */
34922 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
34923 } else {
34924 zend_binary_op(zptr, zptr, value OPLINE_CC);
34925 }
34926 } while (0);
34927
34928 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34929 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
34930 }
34931 }
34932 } else {
34933 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
34934 }
34935 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
34936 zend_tmp_string_release(tmp_name);
34937 }
34938 } while (0);
34939
34940 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
34941 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
34942
34943 /* assign_obj has two opcodes! */
34944 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34945 }
34946
34947 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34948 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34949 {
34950 USE_OPLINE
34951 zval *object;
34952 zval *property;
34953 zval *zptr;
34954 void **cache_slot;
34955 zend_property_info *prop_info;
34956 zend_object *zobj;
34957 zend_string *name, *tmp_name;
34958
34959 SAVE_OPLINE();
34960 object = &EX(This);
34961 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
34962
34963 do {
34964 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34965 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34966 object = Z_REFVAL_P(object);
34967 goto pre_incdec_object;
34968 }
34969 if (IS_UNUSED == IS_CV
34970 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
34971 ZVAL_UNDEFINED_OP1();
34972 }
34973 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
34974 break;
34975 }
34976
34977 pre_incdec_object:
34978 /* here we are sure we are dealing with an object */
34979 zobj = Z_OBJ_P(object);
34980 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
34981 name = Z_STR_P(property);
34982 } else {
34983 name = zval_try_get_tmp_string(property, &tmp_name);
34984 if (UNEXPECTED(!name)) {
34985 UNDEF_RESULT();
34986 break;
34987 }
34988 }
34989 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
34990 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
34991 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
34992 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34993 ZVAL_NULL(EX_VAR(opline->result.var));
34994 }
34995 } else {
34996 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
34997 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
34998 } else {
34999 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
35000 }
35001 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
35002 }
35003 } else {
35004 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
35005 }
35006 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35007 zend_tmp_string_release(tmp_name);
35008 }
35009 } while (0);
35010
35011 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35012
35013 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35014 }
35015
ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35016 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35017 {
35018 USE_OPLINE
35019 zval *object;
35020 zval *property;
35021 zval *zptr;
35022 void **cache_slot;
35023 zend_property_info *prop_info;
35024 zend_object *zobj;
35025 zend_string *name, *tmp_name;
35026
35027 SAVE_OPLINE();
35028 object = &EX(This);
35029 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35030
35031 do {
35032 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35033 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35034 object = Z_REFVAL_P(object);
35035 goto post_incdec_object;
35036 }
35037 if (IS_UNUSED == IS_CV
35038 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35039 ZVAL_UNDEFINED_OP1();
35040 }
35041 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35042 break;
35043 }
35044
35045 post_incdec_object:
35046 /* here we are sure we are dealing with an object */
35047 zobj = Z_OBJ_P(object);
35048 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35049 name = Z_STR_P(property);
35050 } else {
35051 name = zval_try_get_tmp_string(property, &tmp_name);
35052 if (UNEXPECTED(!name)) {
35053 ZVAL_UNDEF(EX_VAR(opline->result.var));
35054 break;
35055 }
35056 }
35057 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
35058 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35059 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35060 ZVAL_NULL(EX_VAR(opline->result.var));
35061 } else {
35062 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35063 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
35064 } else {
35065 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
35066 }
35067
35068 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
35069 }
35070 } else {
35071 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
35072 }
35073 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35074 zend_tmp_string_release(tmp_name);
35075 }
35076 } while (0);
35077
35078 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35079
35080 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35081 }
35082
ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35083 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35084 {
35085 USE_OPLINE
35086 zval *container;
35087 void **cache_slot = NULL;
35088
35089 SAVE_OPLINE();
35090 container = &EX(This);
35091
35092 if (IS_UNUSED == IS_CONST ||
35093 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
35094 do {
35095 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
35096 container = Z_REFVAL_P(container);
35097 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
35098 break;
35099 }
35100 }
35101 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
35102 ZVAL_UNDEFINED_OP1();
35103 }
35104 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35105 ZVAL_NULL(EX_VAR(opline->result.var));
35106 goto fetch_obj_r_finish;
35107 } while (0);
35108 }
35109
35110 /* here we are sure we are dealing with an object */
35111 do {
35112 zend_object *zobj = Z_OBJ_P(container);
35113 zend_string *name, *tmp_name;
35114 zval *retval;
35115
35116 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35117 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
35118
35119 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
35120 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35121
35122 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35123 retval = OBJ_PROP(zobj, prop_offset);
35124 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
35125 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35126 goto fetch_obj_r_copy;
35127 } else {
35128 fetch_obj_r_fast_copy:
35129 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
35130 ZEND_VM_NEXT_OPCODE();
35131 }
35132 }
35133 } else if (EXPECTED(zobj->properties != NULL)) {
35134 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35135 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
35136 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
35137
35138 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
35139 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
35140
35141 if (EXPECTED(p->key == name) ||
35142 (EXPECTED(p->h == ZSTR_H(name)) &&
35143 EXPECTED(p->key != NULL) &&
35144 EXPECTED(zend_string_equal_content(p->key, name)))) {
35145 retval = &p->val;
35146 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35147 goto fetch_obj_r_copy;
35148 } else {
35149 goto fetch_obj_r_fast_copy;
35150 }
35151 }
35152 }
35153 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
35154 }
35155 retval = zend_hash_find_known_hash(zobj->properties, name);
35156 if (EXPECTED(retval)) {
35157 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
35158 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
35159 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35160 goto fetch_obj_r_copy;
35161 } else {
35162 goto fetch_obj_r_fast_copy;
35163 }
35164 }
35165 }
35166 }
35167 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35168 } else {
35169 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35170 if (UNEXPECTED(!name)) {
35171 ZVAL_UNDEF(EX_VAR(opline->result.var));
35172 break;
35173 }
35174 }
35175
35176 #if ZEND_DEBUG
35177 /* For non-standard object handlers, verify a declared property type in debug builds.
35178 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
35179 zend_property_info *prop_info = NULL;
35180 if (zobj->handlers->read_property != zend_std_read_property) {
35181 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
35182 }
35183 #endif
35184 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
35185 #if ZEND_DEBUG
35186 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
35187 && ZEND_TYPE_IS_SET(prop_info->type)) {
35188 ZVAL_OPT_DEREF(retval);
35189 zend_verify_property_type(prop_info, retval, /* strict */ true);
35190 }
35191 #endif
35192
35193 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35194 zend_tmp_string_release(tmp_name);
35195 }
35196
35197 if (retval != EX_VAR(opline->result.var)) {
35198 fetch_obj_r_copy:
35199 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
35200 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
35201 zend_unwrap_reference(retval);
35202 }
35203 } while (0);
35204
35205 fetch_obj_r_finish:
35206 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35207
35208 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35209 }
35210
ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35211 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35212 {
35213 USE_OPLINE
35214 zval *property, *container, *result;
35215
35216 SAVE_OPLINE();
35217
35218 container = &EX(This);
35219 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35220 result = EX_VAR(opline->result.var);
35221 zend_fetch_property_address(
35222 result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR),
35223 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
35224 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
35225 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35226 if (IS_UNUSED == IS_VAR) {
35227 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
35228 }
35229 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35230 }
35231
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35232 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35233 {
35234 USE_OPLINE
35235 zval *property, *container, *result;
35236
35237 SAVE_OPLINE();
35238 container = &EX(This);
35239 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35240 result = EX_VAR(opline->result.var);
35241 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);
35242 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35243 if (IS_UNUSED == IS_VAR) {
35244 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
35245 }
35246 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35247 }
35248
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35249 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35250 {
35251 USE_OPLINE
35252 zval *container;
35253 void **cache_slot = NULL;
35254
35255 SAVE_OPLINE();
35256 container = &EX(This);
35257
35258 if (IS_UNUSED == IS_CONST ||
35259 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
35260 do {
35261 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
35262 container = Z_REFVAL_P(container);
35263 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
35264 break;
35265 }
35266 }
35267 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
35268 ZVAL_UNDEFINED_OP2();
35269 }
35270 ZVAL_NULL(EX_VAR(opline->result.var));
35271 goto fetch_obj_is_finish;
35272 } while (0);
35273 }
35274
35275 /* here we are sure we are dealing with an object */
35276 do {
35277 zend_object *zobj = Z_OBJ_P(container);
35278 zend_string *name, *tmp_name;
35279 zval *retval;
35280
35281 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35282 cache_slot = CACHE_ADDR(opline->extended_value);
35283
35284 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
35285 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35286
35287 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35288 retval = OBJ_PROP(zobj, prop_offset);
35289 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
35290 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35291 goto fetch_obj_is_copy;
35292 } else {
35293 fetch_obj_is_fast_copy:
35294 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
35295 ZEND_VM_NEXT_OPCODE();
35296 }
35297 }
35298 } else if (EXPECTED(zobj->properties != NULL)) {
35299 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35300 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
35301 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
35302
35303 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
35304 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
35305
35306 if (EXPECTED(p->key == name) ||
35307 (EXPECTED(p->h == ZSTR_H(name)) &&
35308 EXPECTED(p->key != NULL) &&
35309 EXPECTED(zend_string_equal_content(p->key, name)))) {
35310 retval = &p->val;
35311 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35312 goto fetch_obj_is_copy;
35313 } else {
35314 goto fetch_obj_is_fast_copy;
35315 }
35316 }
35317 }
35318 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
35319 }
35320 retval = zend_hash_find_known_hash(zobj->properties, name);
35321 if (EXPECTED(retval)) {
35322 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
35323 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
35324 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35325 goto fetch_obj_is_copy;
35326 } else {
35327 goto fetch_obj_is_fast_copy;
35328 }
35329 }
35330 }
35331 }
35332 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35333 } else {
35334 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35335 if (UNEXPECTED(!name)) {
35336 ZVAL_UNDEF(EX_VAR(opline->result.var));
35337 break;
35338 }
35339 }
35340
35341 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
35342
35343 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35344 zend_tmp_string_release(tmp_name);
35345 }
35346
35347 if (retval != EX_VAR(opline->result.var)) {
35348 fetch_obj_is_copy:
35349 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
35350 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
35351 zend_unwrap_reference(retval);
35352 }
35353 } while (0);
35354
35355 fetch_obj_is_finish:
35356 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35357
35358 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35359 }
35360
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35361 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35362 {
35363 #if 0
35364 USE_OPLINE
35365 #endif
35366
35367 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
35368 /* Behave like FETCH_OBJ_W */
35369 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
35370 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35371 }
35372 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35373 } else {
35374 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35375 }
35376 }
35377
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35378 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35379 {
35380 USE_OPLINE
35381 zval *container, *property, *result;
35382
35383 SAVE_OPLINE();
35384 container = &EX(This);
35385 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35386 result = EX_VAR(opline->result.var);
35387 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);
35388 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35389 if (IS_UNUSED == IS_VAR) {
35390 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
35391 }
35392 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35393 }
35394
ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35395 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35396 {
35397 USE_OPLINE
35398 zval *object, *value, tmp;
35399 zend_object *zobj;
35400 zend_string *name, *tmp_name;
35401 zend_refcounted *garbage = NULL;
35402
35403 SAVE_OPLINE();
35404 object = &EX(This);
35405 value = RT_CONSTANT((opline+1), (opline+1)->op1);
35406
35407 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35408 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35409 object = Z_REFVAL_P(object);
35410 goto assign_object;
35411 }
35412 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
35413 value = &EG(uninitialized_zval);
35414 goto free_and_exit_assign_obj;
35415 }
35416
35417 assign_object:
35418 zobj = Z_OBJ_P(object);
35419 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35420 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
35421 void **cache_slot = CACHE_ADDR(opline->extended_value);
35422 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35423 zval *property_val;
35424
35425 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35426 property_val = OBJ_PROP(zobj, prop_offset);
35427 if (Z_TYPE_P(property_val) != IS_UNDEF) {
35428 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
35429
35430 if (prop_info != NULL) {
35431 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
35432 goto free_and_exit_assign_obj;
35433 } else {
35434 fast_assign_obj:
35435 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
35436 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35437 ZVAL_COPY(EX_VAR(opline->result.var), value);
35438 }
35439 goto exit_assign_obj;
35440 }
35441 }
35442 } else {
35443 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35444 if (EXPECTED(zobj->properties != NULL)) {
35445 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
35446 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
35447 GC_DELREF(zobj->properties);
35448 }
35449 zobj->properties = zend_array_dup(zobj->properties);
35450 }
35451 property_val = zend_hash_find_known_hash(zobj->properties, name);
35452 if (property_val) {
35453 goto fast_assign_obj;
35454 }
35455 }
35456
35457 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
35458 if (EXPECTED(zobj->properties == NULL)) {
35459 rebuild_object_properties(zobj);
35460 }
35461 if (IS_CONST == IS_CONST) {
35462 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
35463 Z_ADDREF_P(value);
35464 }
35465 } else if (IS_CONST != IS_TMP_VAR) {
35466 if (Z_ISREF_P(value)) {
35467 if (IS_CONST == IS_VAR) {
35468 zend_reference *ref = Z_REF_P(value);
35469 if (GC_DELREF(ref) == 0) {
35470 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
35471 efree_size(ref, sizeof(zend_reference));
35472 value = &tmp;
35473 } else {
35474 value = Z_REFVAL_P(value);
35475 Z_TRY_ADDREF_P(value);
35476 }
35477 } else {
35478 value = Z_REFVAL_P(value);
35479 Z_TRY_ADDREF_P(value);
35480 }
35481 } else if (IS_CONST == IS_CV) {
35482 Z_TRY_ADDREF_P(value);
35483 }
35484 }
35485 zend_hash_add_new(zobj->properties, name, value);
35486 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35487 ZVAL_COPY(EX_VAR(opline->result.var), value);
35488 }
35489 goto exit_assign_obj;
35490 }
35491 }
35492 }
35493 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35494 } else {
35495 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35496 if (UNEXPECTED(!name)) {
35497
35498 UNDEF_RESULT();
35499 goto exit_assign_obj;
35500 }
35501 }
35502
35503 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
35504 ZVAL_DEREF(value);
35505 }
35506
35507 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
35508
35509 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35510 zend_tmp_string_release(tmp_name);
35511 }
35512
35513 free_and_exit_assign_obj:
35514 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
35515 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
35516 }
35517
35518 exit_assign_obj:
35519 if (garbage) {
35520 GC_DTOR_NO_REF(garbage);
35521 }
35522 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35523
35524 /* assign_obj has two opcodes! */
35525 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35526 }
35527
35528 /* 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)35529 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35530 {
35531 USE_OPLINE
35532 zval *object, *value, tmp;
35533 zend_object *zobj;
35534 zend_string *name, *tmp_name;
35535 zend_refcounted *garbage = NULL;
35536
35537 SAVE_OPLINE();
35538 object = &EX(This);
35539 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
35540
35541 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35542 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35543 object = Z_REFVAL_P(object);
35544 goto assign_object;
35545 }
35546 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
35547 value = &EG(uninitialized_zval);
35548 goto free_and_exit_assign_obj;
35549 }
35550
35551 assign_object:
35552 zobj = Z_OBJ_P(object);
35553 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35554 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
35555 void **cache_slot = CACHE_ADDR(opline->extended_value);
35556 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35557 zval *property_val;
35558
35559 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35560 property_val = OBJ_PROP(zobj, prop_offset);
35561 if (Z_TYPE_P(property_val) != IS_UNDEF) {
35562 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
35563
35564 if (prop_info != NULL) {
35565 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
35566 goto free_and_exit_assign_obj;
35567 } else {
35568 fast_assign_obj:
35569 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
35570 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35571 ZVAL_COPY(EX_VAR(opline->result.var), value);
35572 }
35573 goto exit_assign_obj;
35574 }
35575 }
35576 } else {
35577 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35578 if (EXPECTED(zobj->properties != NULL)) {
35579 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
35580 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
35581 GC_DELREF(zobj->properties);
35582 }
35583 zobj->properties = zend_array_dup(zobj->properties);
35584 }
35585 property_val = zend_hash_find_known_hash(zobj->properties, name);
35586 if (property_val) {
35587 goto fast_assign_obj;
35588 }
35589 }
35590
35591 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
35592 if (EXPECTED(zobj->properties == NULL)) {
35593 rebuild_object_properties(zobj);
35594 }
35595 if (IS_TMP_VAR == IS_CONST) {
35596 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
35597 Z_ADDREF_P(value);
35598 }
35599 } else if (IS_TMP_VAR != IS_TMP_VAR) {
35600 if (Z_ISREF_P(value)) {
35601 if (IS_TMP_VAR == IS_VAR) {
35602 zend_reference *ref = Z_REF_P(value);
35603 if (GC_DELREF(ref) == 0) {
35604 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
35605 efree_size(ref, sizeof(zend_reference));
35606 value = &tmp;
35607 } else {
35608 value = Z_REFVAL_P(value);
35609 Z_TRY_ADDREF_P(value);
35610 }
35611 } else {
35612 value = Z_REFVAL_P(value);
35613 Z_TRY_ADDREF_P(value);
35614 }
35615 } else if (IS_TMP_VAR == IS_CV) {
35616 Z_TRY_ADDREF_P(value);
35617 }
35618 }
35619 zend_hash_add_new(zobj->properties, name, value);
35620 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35621 ZVAL_COPY(EX_VAR(opline->result.var), value);
35622 }
35623 goto exit_assign_obj;
35624 }
35625 }
35626 }
35627 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35628 } else {
35629 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35630 if (UNEXPECTED(!name)) {
35631 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
35632 UNDEF_RESULT();
35633 goto exit_assign_obj;
35634 }
35635 }
35636
35637 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
35638 ZVAL_DEREF(value);
35639 }
35640
35641 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
35642
35643 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35644 zend_tmp_string_release(tmp_name);
35645 }
35646
35647 free_and_exit_assign_obj:
35648 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
35649 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
35650 }
35651 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
35652 exit_assign_obj:
35653 if (garbage) {
35654 GC_DTOR_NO_REF(garbage);
35655 }
35656 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35657
35658 /* assign_obj has two opcodes! */
35659 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35660 }
35661
35662 /* 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)35663 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35664 {
35665 USE_OPLINE
35666 zval *object, *value, tmp;
35667 zend_object *zobj;
35668 zend_string *name, *tmp_name;
35669 zend_refcounted *garbage = NULL;
35670
35671 SAVE_OPLINE();
35672 object = &EX(This);
35673 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
35674
35675 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35676 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35677 object = Z_REFVAL_P(object);
35678 goto assign_object;
35679 }
35680 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
35681 value = &EG(uninitialized_zval);
35682 goto free_and_exit_assign_obj;
35683 }
35684
35685 assign_object:
35686 zobj = Z_OBJ_P(object);
35687 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35688 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
35689 void **cache_slot = CACHE_ADDR(opline->extended_value);
35690 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35691 zval *property_val;
35692
35693 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35694 property_val = OBJ_PROP(zobj, prop_offset);
35695 if (Z_TYPE_P(property_val) != IS_UNDEF) {
35696 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
35697
35698 if (prop_info != NULL) {
35699 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
35700 goto free_and_exit_assign_obj;
35701 } else {
35702 fast_assign_obj:
35703 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
35704 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35705 ZVAL_COPY(EX_VAR(opline->result.var), value);
35706 }
35707 goto exit_assign_obj;
35708 }
35709 }
35710 } else {
35711 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35712 if (EXPECTED(zobj->properties != NULL)) {
35713 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
35714 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
35715 GC_DELREF(zobj->properties);
35716 }
35717 zobj->properties = zend_array_dup(zobj->properties);
35718 }
35719 property_val = zend_hash_find_known_hash(zobj->properties, name);
35720 if (property_val) {
35721 goto fast_assign_obj;
35722 }
35723 }
35724
35725 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
35726 if (EXPECTED(zobj->properties == NULL)) {
35727 rebuild_object_properties(zobj);
35728 }
35729 if (IS_VAR == IS_CONST) {
35730 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
35731 Z_ADDREF_P(value);
35732 }
35733 } else if (IS_VAR != IS_TMP_VAR) {
35734 if (Z_ISREF_P(value)) {
35735 if (IS_VAR == IS_VAR) {
35736 zend_reference *ref = Z_REF_P(value);
35737 if (GC_DELREF(ref) == 0) {
35738 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
35739 efree_size(ref, sizeof(zend_reference));
35740 value = &tmp;
35741 } else {
35742 value = Z_REFVAL_P(value);
35743 Z_TRY_ADDREF_P(value);
35744 }
35745 } else {
35746 value = Z_REFVAL_P(value);
35747 Z_TRY_ADDREF_P(value);
35748 }
35749 } else if (IS_VAR == IS_CV) {
35750 Z_TRY_ADDREF_P(value);
35751 }
35752 }
35753 zend_hash_add_new(zobj->properties, name, value);
35754 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35755 ZVAL_COPY(EX_VAR(opline->result.var), value);
35756 }
35757 goto exit_assign_obj;
35758 }
35759 }
35760 }
35761 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35762 } else {
35763 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35764 if (UNEXPECTED(!name)) {
35765 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
35766 UNDEF_RESULT();
35767 goto exit_assign_obj;
35768 }
35769 }
35770
35771 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
35772 ZVAL_DEREF(value);
35773 }
35774
35775 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
35776
35777 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35778 zend_tmp_string_release(tmp_name);
35779 }
35780
35781 free_and_exit_assign_obj:
35782 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
35783 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
35784 }
35785 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
35786 exit_assign_obj:
35787 if (garbage) {
35788 GC_DTOR_NO_REF(garbage);
35789 }
35790 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35791
35792 /* assign_obj has two opcodes! */
35793 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35794 }
35795
35796 /* 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)35797 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35798 {
35799 USE_OPLINE
35800 zval *object, *value, tmp;
35801 zend_object *zobj;
35802 zend_string *name, *tmp_name;
35803 zend_refcounted *garbage = NULL;
35804
35805 SAVE_OPLINE();
35806 object = &EX(This);
35807 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
35808
35809 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35810 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35811 object = Z_REFVAL_P(object);
35812 goto assign_object;
35813 }
35814 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
35815 value = &EG(uninitialized_zval);
35816 goto free_and_exit_assign_obj;
35817 }
35818
35819 assign_object:
35820 zobj = Z_OBJ_P(object);
35821 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35822 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
35823 void **cache_slot = CACHE_ADDR(opline->extended_value);
35824 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35825 zval *property_val;
35826
35827 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35828 property_val = OBJ_PROP(zobj, prop_offset);
35829 if (Z_TYPE_P(property_val) != IS_UNDEF) {
35830 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
35831
35832 if (prop_info != NULL) {
35833 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
35834 goto free_and_exit_assign_obj;
35835 } else {
35836 fast_assign_obj:
35837 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
35838 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35839 ZVAL_COPY(EX_VAR(opline->result.var), value);
35840 }
35841 goto exit_assign_obj;
35842 }
35843 }
35844 } else {
35845 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35846 if (EXPECTED(zobj->properties != NULL)) {
35847 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
35848 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
35849 GC_DELREF(zobj->properties);
35850 }
35851 zobj->properties = zend_array_dup(zobj->properties);
35852 }
35853 property_val = zend_hash_find_known_hash(zobj->properties, name);
35854 if (property_val) {
35855 goto fast_assign_obj;
35856 }
35857 }
35858
35859 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
35860 if (EXPECTED(zobj->properties == NULL)) {
35861 rebuild_object_properties(zobj);
35862 }
35863 if (IS_CV == IS_CONST) {
35864 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
35865 Z_ADDREF_P(value);
35866 }
35867 } else if (IS_CV != IS_TMP_VAR) {
35868 if (Z_ISREF_P(value)) {
35869 if (IS_CV == IS_VAR) {
35870 zend_reference *ref = Z_REF_P(value);
35871 if (GC_DELREF(ref) == 0) {
35872 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
35873 efree_size(ref, sizeof(zend_reference));
35874 value = &tmp;
35875 } else {
35876 value = Z_REFVAL_P(value);
35877 Z_TRY_ADDREF_P(value);
35878 }
35879 } else {
35880 value = Z_REFVAL_P(value);
35881 Z_TRY_ADDREF_P(value);
35882 }
35883 } else if (IS_CV == IS_CV) {
35884 Z_TRY_ADDREF_P(value);
35885 }
35886 }
35887 zend_hash_add_new(zobj->properties, name, value);
35888 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35889 ZVAL_COPY(EX_VAR(opline->result.var), value);
35890 }
35891 goto exit_assign_obj;
35892 }
35893 }
35894 }
35895 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35896 } else {
35897 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35898 if (UNEXPECTED(!name)) {
35899
35900 UNDEF_RESULT();
35901 goto exit_assign_obj;
35902 }
35903 }
35904
35905 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
35906 ZVAL_DEREF(value);
35907 }
35908
35909 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
35910
35911 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35912 zend_tmp_string_release(tmp_name);
35913 }
35914
35915 free_and_exit_assign_obj:
35916 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
35917 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
35918 }
35919
35920 exit_assign_obj:
35921 if (garbage) {
35922 GC_DTOR_NO_REF(garbage);
35923 }
35924 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35925
35926 /* assign_obj has two opcodes! */
35927 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35928 }
35929
35930 /* 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)35931 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35932 {
35933 USE_OPLINE
35934 zval *property, *container, *value_ptr;
35935
35936 SAVE_OPLINE();
35937
35938 container = &EX(This);
35939 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35940
35941 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
35942
35943 if (1) {
35944 if (IS_UNUSED == IS_UNUSED) {
35945 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35946 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35947 } else {
35948 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35949 }
35950 } else {
35951 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35952 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35953 } else {
35954 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35955 }
35956 }
35957 } else {
35958 zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
35959 }
35960
35961 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35962 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
35963 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35964 }
35965
35966 /* 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)35967 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35968 {
35969 USE_OPLINE
35970 zval *property, *container, *value_ptr;
35971
35972 SAVE_OPLINE();
35973
35974 container = &EX(This);
35975 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35976
35977 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
35978
35979 if (1) {
35980 if (IS_UNUSED == IS_UNUSED) {
35981 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35982 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35983 } else {
35984 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35985 }
35986 } else {
35987 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35988 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35989 } else {
35990 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35991 }
35992 }
35993 } else {
35994 zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
35995 }
35996
35997 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35998
35999 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36000 }
36001
36002 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36003 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36004 {
36005 USE_OPLINE
36006 zend_string **rope;
36007 zval *var;
36008
36009 /* Compiler allocates the necessary number of zval slots to keep the rope */
36010 rope = (zend_string**)EX_VAR(opline->result.var);
36011 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36012 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36013 rope[0] = Z_STR_P(var);
36014 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
36015 Z_ADDREF_P(var);
36016 }
36017 } else {
36018 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36019 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
36020 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
36021 rope[0] = zend_string_copy(Z_STR_P(var));
36022 } else {
36023 rope[0] = Z_STR_P(var);
36024 }
36025 } else {
36026 SAVE_OPLINE();
36027 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
36028 ZVAL_UNDEFINED_OP2();
36029 }
36030 rope[0] = zval_get_string_func(var);
36031 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36032 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36033 }
36034 }
36035 ZEND_VM_NEXT_OPCODE();
36036 }
36037
ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36038 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36039 {
36040 zval *class_name;
36041 USE_OPLINE
36042
36043 SAVE_OPLINE();
36044 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
36045 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
36046 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36047 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36048 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
36049
36050 if (UNEXPECTED(ce == NULL)) {
36051 class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36052 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
36053 CACHE_PTR(opline->extended_value, ce);
36054 }
36055 Z_CE_P(EX_VAR(opline->result.var)) = ce;
36056 } else {
36057 class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36058 try_class_name:
36059 if (Z_TYPE_P(class_name) == IS_OBJECT) {
36060 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
36061 } else if (Z_TYPE_P(class_name) == IS_STRING) {
36062 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
36063 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
36064 class_name = Z_REFVAL_P(class_name);
36065 goto try_class_name;
36066 } else {
36067 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
36068 ZVAL_UNDEFINED_OP2();
36069 if (UNEXPECTED(EG(exception) != NULL)) {
36070 HANDLE_EXCEPTION();
36071 }
36072 }
36073 zend_throw_error(NULL, "Class name must be a valid object or a string");
36074 }
36075 }
36076
36077 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36078 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36079 }
36080
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36081 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36082 {
36083 USE_OPLINE
36084 zval *function_name;
36085 zval *object;
36086 zend_function *fbc;
36087 zend_class_entry *called_scope;
36088 zend_object *obj;
36089 zend_execute_data *call;
36090 uint32_t call_info;
36091
36092 SAVE_OPLINE();
36093
36094 object = &EX(This);
36095
36096 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36097 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36098 }
36099
36100 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
36101 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
36102 do {
36103 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
36104 function_name = Z_REFVAL_P(function_name);
36105 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
36106 break;
36107 }
36108 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
36109 ZVAL_UNDEFINED_OP2();
36110 if (UNEXPECTED(EG(exception) != NULL)) {
36111
36112 HANDLE_EXCEPTION();
36113 }
36114 }
36115 zend_throw_error(NULL, "Method name must be a string");
36116 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36117
36118 HANDLE_EXCEPTION();
36119 } while (0);
36120 }
36121
36122 if (IS_UNUSED == IS_UNUSED) {
36123 obj = Z_OBJ_P(object);
36124 } else {
36125 do {
36126 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
36127 obj = Z_OBJ_P(object);
36128 } else {
36129 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
36130 zend_reference *ref = Z_REF_P(object);
36131
36132 object = &ref->val;
36133 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
36134 obj = Z_OBJ_P(object);
36135 if (IS_UNUSED & IS_VAR) {
36136 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
36137 efree_size(ref, sizeof(zend_reference));
36138 } else {
36139 Z_ADDREF_P(object);
36140 }
36141 }
36142 break;
36143 }
36144 }
36145 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
36146 object = ZVAL_UNDEFINED_OP1();
36147 if (UNEXPECTED(EG(exception) != NULL)) {
36148 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36149 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36150 }
36151 HANDLE_EXCEPTION();
36152 }
36153 }
36154 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36155 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36156 }
36157 zend_invalid_method_call(object, function_name);
36158 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36159
36160 HANDLE_EXCEPTION();
36161 }
36162 } while (0);
36163 }
36164
36165 called_scope = obj->ce;
36166
36167 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
36168 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
36169 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
36170 } else {
36171 zend_object *orig_obj = obj;
36172
36173 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36174 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36175 }
36176
36177 /* First, locate the function. */
36178 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));
36179 if (UNEXPECTED(fbc == NULL)) {
36180 if (EXPECTED(!EG(exception))) {
36181 zend_undefined_method(obj->ce, Z_STR_P(function_name));
36182 }
36183 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36184 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
36185 zend_objects_store_del(orig_obj);
36186 }
36187 HANDLE_EXCEPTION();
36188 }
36189 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
36190 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
36191 EXPECTED(obj == orig_obj)) {
36192 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
36193 }
36194 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
36195 GC_ADDREF(obj); /* For $this pointer */
36196 if (GC_DELREF(orig_obj) == 0) {
36197 zend_objects_store_del(orig_obj);
36198 }
36199 }
36200 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
36201 init_func_run_time_cache(&fbc->op_array);
36202 }
36203 }
36204
36205 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36206 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36207 }
36208
36209 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
36210 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
36211 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
36212 zend_objects_store_del(obj);
36213 if (UNEXPECTED(EG(exception))) {
36214 HANDLE_EXCEPTION();
36215 }
36216 }
36217 /* call static method */
36218 obj = (zend_object*)called_scope;
36219 call_info = ZEND_CALL_NESTED_FUNCTION;
36220 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
36221 if (IS_UNUSED == IS_CV) {
36222 GC_ADDREF(obj); /* For $this pointer */
36223 }
36224 /* CV may be changed indirectly (e.g. when it's a reference) */
36225 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
36226 }
36227
36228 call = zend_vm_stack_push_call_frame(call_info,
36229 fbc, opline->extended_value, obj);
36230 call->prev_execute_data = EX(call);
36231 EX(call) = call;
36232
36233 ZEND_VM_NEXT_OPCODE();
36234 }
36235
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36236 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36237 {
36238 USE_OPLINE
36239 zval *function_name;
36240 zend_class_entry *ce;
36241 uint32_t call_info;
36242 zend_function *fbc;
36243 zend_execute_data *call;
36244
36245 SAVE_OPLINE();
36246
36247 if (IS_UNUSED == IS_CONST) {
36248 /* no function found. try a static method in class */
36249 ce = CACHED_PTR(opline->result.num);
36250 if (UNEXPECTED(ce == NULL)) {
36251 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);
36252 if (UNEXPECTED(ce == NULL)) {
36253 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36254 HANDLE_EXCEPTION();
36255 }
36256 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36257 CACHE_PTR(opline->result.num, ce);
36258 }
36259 }
36260 } else if (IS_UNUSED == IS_UNUSED) {
36261 ce = zend_fetch_class(NULL, opline->op1.num);
36262 if (UNEXPECTED(ce == NULL)) {
36263 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36264 HANDLE_EXCEPTION();
36265 }
36266 } else {
36267 ce = Z_CE_P(EX_VAR(opline->op1.var));
36268 }
36269
36270 if (IS_UNUSED == IS_CONST &&
36271 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
36272 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
36273 /* nothing to do */
36274 } else if (IS_UNUSED != IS_CONST &&
36275 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
36276 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
36277 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
36278 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
36279 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36280 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36281 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
36282 do {
36283 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
36284 function_name = Z_REFVAL_P(function_name);
36285 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
36286 break;
36287 }
36288 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
36289 ZVAL_UNDEFINED_OP2();
36290 if (UNEXPECTED(EG(exception) != NULL)) {
36291 HANDLE_EXCEPTION();
36292 }
36293 }
36294 zend_throw_error(NULL, "Method name must be a string");
36295 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36296 HANDLE_EXCEPTION();
36297 } while (0);
36298 }
36299 }
36300
36301 if (ce->get_static_method) {
36302 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
36303 } else {
36304 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));
36305 }
36306 if (UNEXPECTED(fbc == NULL)) {
36307 if (EXPECTED(!EG(exception))) {
36308 zend_undefined_method(ce, Z_STR_P(function_name));
36309 }
36310 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36311 HANDLE_EXCEPTION();
36312 }
36313 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
36314 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
36315 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
36316 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
36317 }
36318 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
36319 init_func_run_time_cache(&fbc->op_array);
36320 }
36321 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36322 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36323 }
36324 } else {
36325 if (UNEXPECTED(ce->constructor == NULL)) {
36326 zend_throw_error(NULL, "Cannot call constructor");
36327 HANDLE_EXCEPTION();
36328 }
36329 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
36330 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
36331 HANDLE_EXCEPTION();
36332 }
36333 fbc = ce->constructor;
36334 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
36335 init_func_run_time_cache(&fbc->op_array);
36336 }
36337 }
36338
36339 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
36340 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
36341 ce = (zend_class_entry*)Z_OBJ(EX(This));
36342 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
36343 } else {
36344 zend_non_static_method_call(fbc);
36345 HANDLE_EXCEPTION();
36346 }
36347 } else {
36348 /* previous opcode is ZEND_FETCH_CLASS */
36349 if (IS_UNUSED == IS_UNUSED
36350 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
36351 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
36352 if (Z_TYPE(EX(This)) == IS_OBJECT) {
36353 ce = Z_OBJCE(EX(This));
36354 } else {
36355 ce = Z_CE(EX(This));
36356 }
36357 }
36358 call_info = ZEND_CALL_NESTED_FUNCTION;
36359 }
36360
36361 call = zend_vm_stack_push_call_frame(call_info,
36362 fbc, opline->extended_value, ce);
36363 call->prev_execute_data = EX(call);
36364 EX(call) = call;
36365
36366 ZEND_VM_NEXT_OPCODE();
36367 }
36368
ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36369 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36370 {
36371 zval *array;
36372 uint32_t size;
36373 USE_OPLINE
36374
36375 array = EX_VAR(opline->result.var);
36376 if (IS_UNUSED != IS_UNUSED) {
36377 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
36378 ZVAL_ARR(array, zend_new_array(size));
36379 /* Explicitly initialize array as not-packed if flag is set */
36380 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
36381 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
36382 }
36383 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36384 } else {
36385 ZVAL_ARR(array, zend_new_array(0));
36386 ZEND_VM_NEXT_OPCODE();
36387 }
36388 }
36389
ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36390 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36391 {
36392 USE_OPLINE
36393 zval *container;
36394 zval *offset;
36395 zend_string *name, *tmp_name;
36396
36397 SAVE_OPLINE();
36398 container = &EX(This);
36399 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36400
36401 do {
36402 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
36403 if (Z_ISREF_P(container)) {
36404 container = Z_REFVAL_P(container);
36405 if (Z_TYPE_P(container) != IS_OBJECT) {
36406 if (IS_UNUSED == IS_CV
36407 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
36408 ZVAL_UNDEFINED_OP1();
36409 }
36410 break;
36411 }
36412 } else {
36413 break;
36414 }
36415 }
36416 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36417 name = Z_STR_P(offset);
36418 } else {
36419 name = zval_try_get_tmp_string(offset, &tmp_name);
36420 if (UNEXPECTED(!name)) {
36421 break;
36422 }
36423 }
36424 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));
36425 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36426 zend_tmp_string_release(tmp_name);
36427 }
36428 } while (0);
36429
36430 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36431
36432 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36433 }
36434
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36435 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36436 {
36437 USE_OPLINE
36438 zval *container;
36439 int result;
36440 zval *offset;
36441 zend_string *name, *tmp_name;
36442
36443 SAVE_OPLINE();
36444 container = &EX(This);
36445 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36446
36447 if (IS_UNUSED == IS_CONST ||
36448 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
36449 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
36450 container = Z_REFVAL_P(container);
36451 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
36452 result = (opline->extended_value & ZEND_ISEMPTY);
36453 goto isset_object_finish;
36454 }
36455 } else {
36456 result = (opline->extended_value & ZEND_ISEMPTY);
36457 goto isset_object_finish;
36458 }
36459 }
36460
36461 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36462 name = Z_STR_P(offset);
36463 } else {
36464 name = zval_try_get_tmp_string(offset, &tmp_name);
36465 if (UNEXPECTED(!name)) {
36466 result = 0;
36467 goto isset_object_finish;
36468 }
36469 }
36470
36471 result =
36472 (opline->extended_value & ZEND_ISEMPTY) ^
36473 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));
36474
36475 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36476 zend_tmp_string_release(tmp_name);
36477 }
36478
36479 isset_object_finish:
36480 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36481
36482 ZEND_VM_SMART_BRANCH(result, 1);
36483 }
36484
ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36485 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36486 {
36487 USE_OPLINE
36488
36489 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
36490
36491 SAVE_OPLINE();
36492 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
36493 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36494 }
36495
36496 /* Destroy the previously yielded value */
36497 zval_ptr_dtor(&generator->value);
36498
36499 /* Destroy the previously yielded key */
36500 zval_ptr_dtor(&generator->key);
36501
36502 /* Set the new yielded value */
36503 if (IS_UNUSED != IS_UNUSED) {
36504 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
36505 /* Constants and temporary variables aren't yieldable by reference,
36506 * but we still allow them with a notice. */
36507 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
36508 zval *value;
36509
36510 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
36511
36512 value = NULL;
36513 ZVAL_COPY_VALUE(&generator->value, value);
36514 if (IS_UNUSED == IS_CONST) {
36515 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
36516 Z_ADDREF(generator->value);
36517 }
36518 }
36519 } else {
36520 zval *value_ptr = NULL;
36521
36522 /* If a function call result is yielded and the function did
36523 * not return by reference we throw a notice. */
36524 do {
36525 if (IS_UNUSED == IS_VAR) {
36526 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
36527 if (opline->extended_value == ZEND_RETURNS_FUNCTION
36528 && !Z_ISREF_P(value_ptr)) {
36529 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
36530 ZVAL_COPY(&generator->value, value_ptr);
36531 break;
36532 }
36533 }
36534 if (Z_ISREF_P(value_ptr)) {
36535 Z_ADDREF_P(value_ptr);
36536 } else {
36537 ZVAL_MAKE_REF_EX(value_ptr, 2);
36538 }
36539 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
36540 } while (0);
36541
36542 }
36543 } else {
36544 zval *value = NULL;
36545
36546 /* Consts, temporary variables and references need copying */
36547 if (IS_UNUSED == IS_CONST) {
36548 ZVAL_COPY_VALUE(&generator->value, value);
36549 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
36550 Z_ADDREF(generator->value);
36551 }
36552 } else if (IS_UNUSED == IS_TMP_VAR) {
36553 ZVAL_COPY_VALUE(&generator->value, value);
36554 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
36555 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
36556
36557 } else {
36558 ZVAL_COPY_VALUE(&generator->value, value);
36559 if (IS_UNUSED == IS_CV) {
36560 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
36561 }
36562 }
36563 }
36564 } else {
36565 /* If no value was specified yield null */
36566 ZVAL_NULL(&generator->value);
36567 }
36568
36569 /* Set the new yielded key */
36570 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
36571 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36572 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
36573 key = Z_REFVAL_P(key);
36574 }
36575 ZVAL_COPY(&generator->key, key);
36576 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36577
36578 if (Z_TYPE(generator->key) == IS_LONG
36579 && Z_LVAL(generator->key) > generator->largest_used_integer_key
36580 ) {
36581 generator->largest_used_integer_key = Z_LVAL(generator->key);
36582 }
36583 } else {
36584 /* If no key was specified we use auto-increment keys */
36585 generator->largest_used_integer_key++;
36586 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
36587 }
36588
36589 if (RETURN_VALUE_USED(opline)) {
36590 /* If the return value of yield is used set the send
36591 * target and initialize it to NULL */
36592 generator->send_target = EX_VAR(opline->result.var);
36593 ZVAL_NULL(generator->send_target);
36594 } else {
36595 generator->send_target = NULL;
36596 }
36597
36598 /* We increment to the next op, so we are at the correct position when the
36599 * generator is resumed. */
36600 ZEND_VM_INC_OPCODE();
36601
36602 /* The GOTO VM uses a local opline variable. We need to set the opline
36603 * variable in execute_data so we don't resume at an old position. */
36604 SAVE_OPLINE();
36605
36606 ZEND_VM_RETURN();
36607 }
36608
ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36609 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36610 {
36611 zval *class_name;
36612 USE_OPLINE
36613
36614 SAVE_OPLINE();
36615 if (IS_UNUSED == IS_UNUSED) {
36616 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
36617 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36618 } else if (IS_UNUSED == IS_CONST) {
36619 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
36620
36621 if (UNEXPECTED(ce == NULL)) {
36622 class_name = NULL;
36623 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
36624 CACHE_PTR(opline->extended_value, ce);
36625 }
36626 Z_CE_P(EX_VAR(opline->result.var)) = ce;
36627 } else {
36628 class_name = NULL;
36629 try_class_name:
36630 if (Z_TYPE_P(class_name) == IS_OBJECT) {
36631 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
36632 } else if (Z_TYPE_P(class_name) == IS_STRING) {
36633 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
36634 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
36635 class_name = Z_REFVAL_P(class_name);
36636 goto try_class_name;
36637 } else {
36638 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
36639 ZVAL_UNDEFINED_OP2();
36640 if (UNEXPECTED(EG(exception) != NULL)) {
36641 HANDLE_EXCEPTION();
36642 }
36643 }
36644 zend_throw_error(NULL, "Class name must be a valid object or a string");
36645 }
36646 }
36647
36648 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36649 }
36650
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36651 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36652 {
36653 USE_OPLINE
36654 zval *function_name;
36655 zend_class_entry *ce;
36656 uint32_t call_info;
36657 zend_function *fbc;
36658 zend_execute_data *call;
36659
36660 SAVE_OPLINE();
36661
36662 if (IS_UNUSED == IS_CONST) {
36663 /* no function found. try a static method in class */
36664 ce = CACHED_PTR(opline->result.num);
36665 if (UNEXPECTED(ce == NULL)) {
36666 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);
36667 if (UNEXPECTED(ce == NULL)) {
36668
36669 HANDLE_EXCEPTION();
36670 }
36671 if (IS_UNUSED != IS_CONST) {
36672 CACHE_PTR(opline->result.num, ce);
36673 }
36674 }
36675 } else if (IS_UNUSED == IS_UNUSED) {
36676 ce = zend_fetch_class(NULL, opline->op1.num);
36677 if (UNEXPECTED(ce == NULL)) {
36678
36679 HANDLE_EXCEPTION();
36680 }
36681 } else {
36682 ce = Z_CE_P(EX_VAR(opline->op1.var));
36683 }
36684
36685 if (IS_UNUSED == IS_CONST &&
36686 IS_UNUSED == IS_CONST &&
36687 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
36688 /* nothing to do */
36689 } else if (IS_UNUSED != IS_CONST &&
36690 IS_UNUSED == IS_CONST &&
36691 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
36692 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
36693 } else if (IS_UNUSED != IS_UNUSED) {
36694 function_name = NULL;
36695 if (IS_UNUSED != IS_CONST) {
36696 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
36697 do {
36698 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
36699 function_name = Z_REFVAL_P(function_name);
36700 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
36701 break;
36702 }
36703 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
36704 ZVAL_UNDEFINED_OP2();
36705 if (UNEXPECTED(EG(exception) != NULL)) {
36706 HANDLE_EXCEPTION();
36707 }
36708 }
36709 zend_throw_error(NULL, "Method name must be a string");
36710
36711 HANDLE_EXCEPTION();
36712 } while (0);
36713 }
36714 }
36715
36716 if (ce->get_static_method) {
36717 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
36718 } else {
36719 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
36720 }
36721 if (UNEXPECTED(fbc == NULL)) {
36722 if (EXPECTED(!EG(exception))) {
36723 zend_undefined_method(ce, Z_STR_P(function_name));
36724 }
36725
36726 HANDLE_EXCEPTION();
36727 }
36728 if (IS_UNUSED == IS_CONST &&
36729 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
36730 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
36731 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
36732 }
36733 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
36734 init_func_run_time_cache(&fbc->op_array);
36735 }
36736 if (IS_UNUSED != IS_CONST) {
36737
36738 }
36739 } else {
36740 if (UNEXPECTED(ce->constructor == NULL)) {
36741 zend_throw_error(NULL, "Cannot call constructor");
36742 HANDLE_EXCEPTION();
36743 }
36744 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
36745 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
36746 HANDLE_EXCEPTION();
36747 }
36748 fbc = ce->constructor;
36749 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
36750 init_func_run_time_cache(&fbc->op_array);
36751 }
36752 }
36753
36754 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
36755 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
36756 ce = (zend_class_entry*)Z_OBJ(EX(This));
36757 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
36758 } else {
36759 zend_non_static_method_call(fbc);
36760 HANDLE_EXCEPTION();
36761 }
36762 } else {
36763 /* previous opcode is ZEND_FETCH_CLASS */
36764 if (IS_UNUSED == IS_UNUSED
36765 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
36766 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
36767 if (Z_TYPE(EX(This)) == IS_OBJECT) {
36768 ce = Z_OBJCE(EX(This));
36769 } else {
36770 ce = Z_CE(EX(This));
36771 }
36772 }
36773 call_info = ZEND_CALL_NESTED_FUNCTION;
36774 }
36775
36776 call = zend_vm_stack_push_call_frame(call_info,
36777 fbc, opline->extended_value, ce);
36778 call->prev_execute_data = EX(call);
36779 EX(call) = call;
36780
36781 ZEND_VM_NEXT_OPCODE();
36782 }
36783
ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36784 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36785 {
36786 if (IS_UNUSED == IS_UNUSED) {
36787 SAVE_OPLINE();
36788 zend_verify_missing_return_type(EX(func));
36789 HANDLE_EXCEPTION();
36790 } else {
36791 /* prevents "undefined variable opline" errors */
36792 #if 0 || (IS_UNUSED != IS_UNUSED)
36793 USE_OPLINE
36794 zval *retval_ref, *retval_ptr;
36795 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
36796 retval_ref = retval_ptr = NULL;
36797
36798 if (IS_UNUSED == IS_CONST) {
36799 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
36800 retval_ref = retval_ptr = EX_VAR(opline->result.var);
36801 } else if (IS_UNUSED == IS_VAR) {
36802 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
36803 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
36804 }
36805 ZVAL_DEREF(retval_ptr);
36806 } else if (IS_UNUSED == IS_CV) {
36807 ZVAL_DEREF(retval_ptr);
36808 }
36809
36810 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
36811 ZEND_VM_NEXT_OPCODE();
36812 }
36813
36814 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
36815 SAVE_OPLINE();
36816 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
36817 if (UNEXPECTED(EG(exception))) {
36818 HANDLE_EXCEPTION();
36819 }
36820 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
36821 ZEND_VM_NEXT_OPCODE();
36822 }
36823 }
36824
36825 zend_reference *ref = NULL;
36826 void *cache_slot = CACHE_ADDR(opline->op2.num);
36827 if (UNEXPECTED(retval_ref != retval_ptr)) {
36828 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
36829 ref = Z_REF_P(retval_ref);
36830 } else {
36831 /* A cast might happen - unwrap the reference if this is a by-value return */
36832 if (Z_REFCOUNT_P(retval_ref) == 1) {
36833 ZVAL_UNREF(retval_ref);
36834 } else {
36835 Z_DELREF_P(retval_ref);
36836 ZVAL_COPY(retval_ref, retval_ptr);
36837 }
36838 retval_ptr = retval_ref;
36839 }
36840 }
36841
36842 SAVE_OPLINE();
36843 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
36844 zend_verify_return_error(EX(func), retval_ptr);
36845 HANDLE_EXCEPTION();
36846 }
36847 ZEND_VM_NEXT_OPCODE();
36848 #endif
36849 }
36850 }
36851
ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36852 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36853 {
36854 SAVE_OPLINE();
36855 zend_verify_never_error(EX(func));
36856 HANDLE_EXCEPTION();
36857 }
36858
ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36859 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36860 {
36861 USE_OPLINE
36862 uint32_t arg_num;
36863
36864 if (IS_UNUSED == IS_CONST) {
36865 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
36866 arg_num = zend_get_arg_offset_by_name(
36867 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
36868 if (UNEXPECTED(arg_num == 0)) {
36869 /* Treat this as a by-value argument, and throw an error during SEND. */
36870 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36871 ZEND_VM_NEXT_OPCODE();
36872 }
36873 } else {
36874 arg_num = opline->op2.num;
36875 }
36876
36877 if (EXPECTED(0)) {
36878 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
36879 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36880 } else {
36881 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36882 }
36883 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
36884 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36885 } else {
36886 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36887 }
36888 ZEND_VM_NEXT_OPCODE();
36889 }
36890
ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36891 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36892 {
36893 USE_OPLINE
36894 uint32_t arg_num;
36895
36896 if (IS_UNUSED == IS_CONST) {
36897 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
36898 arg_num = zend_get_arg_offset_by_name(
36899 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
36900 if (UNEXPECTED(arg_num == 0)) {
36901 /* Treat this as a by-value argument, and throw an error during SEND. */
36902 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36903 ZEND_VM_NEXT_OPCODE();
36904 }
36905 } else {
36906 arg_num = opline->op2.num;
36907 }
36908
36909 if (EXPECTED(1)) {
36910 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
36911 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36912 } else {
36913 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36914 }
36915 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
36916 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36917 } else {
36918 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36919 }
36920 ZEND_VM_NEXT_OPCODE();
36921 }
36922
ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36923 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36924 {
36925 USE_OPLINE
36926
36927 zend_execute_data *call = execute_data->call;
36928 if (EXPECTED(!(ZEND_CALL_INFO(call) & ZEND_CALL_MAY_HAVE_UNDEF))) {
36929 ZEND_VM_NEXT_OPCODE();
36930 }
36931
36932 SAVE_OPLINE();
36933 zend_handle_undef_args(call);
36934 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36935 }
36936
ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36937 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36938 {
36939 USE_OPLINE
36940 zval *result;
36941 zend_function *constructor;
36942 zend_class_entry *ce;
36943 zend_execute_data *call;
36944
36945 SAVE_OPLINE();
36946 if (IS_UNUSED == IS_CONST) {
36947 ce = CACHED_PTR(opline->op2.num);
36948 if (UNEXPECTED(ce == NULL)) {
36949 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);
36950 if (UNEXPECTED(ce == NULL)) {
36951 ZVAL_UNDEF(EX_VAR(opline->result.var));
36952 HANDLE_EXCEPTION();
36953 }
36954 CACHE_PTR(opline->op2.num, ce);
36955 }
36956 } else if (IS_UNUSED == IS_UNUSED) {
36957 ce = zend_fetch_class(NULL, opline->op1.num);
36958 if (UNEXPECTED(ce == NULL)) {
36959 ZVAL_UNDEF(EX_VAR(opline->result.var));
36960 HANDLE_EXCEPTION();
36961 }
36962 } else {
36963 ce = Z_CE_P(EX_VAR(opline->op1.var));
36964 }
36965
36966 result = EX_VAR(opline->result.var);
36967 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
36968 ZVAL_UNDEF(result);
36969 HANDLE_EXCEPTION();
36970 }
36971
36972 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
36973 if (constructor == NULL) {
36974 if (UNEXPECTED(EG(exception))) {
36975 HANDLE_EXCEPTION();
36976 }
36977
36978 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
36979 * opcode is DO_FCALL in case EXT instructions are used. */
36980 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
36981 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36982 }
36983
36984 /* Perform a dummy function call */
36985 call = zend_vm_stack_push_call_frame(
36986 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
36987 opline->extended_value, NULL);
36988 } else {
36989 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
36990 init_func_run_time_cache(&constructor->op_array);
36991 }
36992 /* We are not handling overloaded classes right now */
36993 call = zend_vm_stack_push_call_frame(
36994 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
36995 constructor,
36996 opline->extended_value,
36997 Z_OBJ_P(result));
36998 Z_ADDREF_P(result);
36999 }
37000
37001 call->prev_execute_data = EX(call);
37002 EX(call) = call;
37003 ZEND_VM_NEXT_OPCODE();
37004 }
37005
ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37006 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37007 {
37008 zval *array;
37009 uint32_t size;
37010 USE_OPLINE
37011
37012 array = EX_VAR(opline->result.var);
37013 if (IS_UNUSED != IS_UNUSED) {
37014 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
37015 ZVAL_ARR(array, zend_new_array(size));
37016 /* Explicitly initialize array as not-packed if flag is set */
37017 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
37018 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
37019 }
37020 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37021 } else {
37022 ZVAL_ARR(array, zend_new_array(0));
37023 ZEND_VM_NEXT_OPCODE();
37024 }
37025 }
37026
ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37027 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37028 {
37029 USE_OPLINE
37030
37031 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
37032
37033 SAVE_OPLINE();
37034 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
37035 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37036 }
37037
37038 /* Destroy the previously yielded value */
37039 zval_ptr_dtor(&generator->value);
37040
37041 /* Destroy the previously yielded key */
37042 zval_ptr_dtor(&generator->key);
37043
37044 /* Set the new yielded value */
37045 if (IS_UNUSED != IS_UNUSED) {
37046 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37047 /* Constants and temporary variables aren't yieldable by reference,
37048 * but we still allow them with a notice. */
37049 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
37050 zval *value;
37051
37052 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37053
37054 value = NULL;
37055 ZVAL_COPY_VALUE(&generator->value, value);
37056 if (IS_UNUSED == IS_CONST) {
37057 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37058 Z_ADDREF(generator->value);
37059 }
37060 }
37061 } else {
37062 zval *value_ptr = NULL;
37063
37064 /* If a function call result is yielded and the function did
37065 * not return by reference we throw a notice. */
37066 do {
37067 if (IS_UNUSED == IS_VAR) {
37068 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
37069 if (opline->extended_value == ZEND_RETURNS_FUNCTION
37070 && !Z_ISREF_P(value_ptr)) {
37071 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37072 ZVAL_COPY(&generator->value, value_ptr);
37073 break;
37074 }
37075 }
37076 if (Z_ISREF_P(value_ptr)) {
37077 Z_ADDREF_P(value_ptr);
37078 } else {
37079 ZVAL_MAKE_REF_EX(value_ptr, 2);
37080 }
37081 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
37082 } while (0);
37083
37084 }
37085 } else {
37086 zval *value = NULL;
37087
37088 /* Consts, temporary variables and references need copying */
37089 if (IS_UNUSED == IS_CONST) {
37090 ZVAL_COPY_VALUE(&generator->value, value);
37091 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37092 Z_ADDREF(generator->value);
37093 }
37094 } else if (IS_UNUSED == IS_TMP_VAR) {
37095 ZVAL_COPY_VALUE(&generator->value, value);
37096 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
37097 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
37098
37099 } else {
37100 ZVAL_COPY_VALUE(&generator->value, value);
37101 if (IS_UNUSED == IS_CV) {
37102 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
37103 }
37104 }
37105 }
37106 } else {
37107 /* If no value was specified yield null */
37108 ZVAL_NULL(&generator->value);
37109 }
37110
37111 /* Set the new yielded key */
37112 if (IS_UNUSED != IS_UNUSED) {
37113 zval *key = NULL;
37114 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
37115 key = Z_REFVAL_P(key);
37116 }
37117 ZVAL_COPY(&generator->key, key);
37118
37119 if (Z_TYPE(generator->key) == IS_LONG
37120 && Z_LVAL(generator->key) > generator->largest_used_integer_key
37121 ) {
37122 generator->largest_used_integer_key = Z_LVAL(generator->key);
37123 }
37124 } else {
37125 /* If no key was specified we use auto-increment keys */
37126 generator->largest_used_integer_key++;
37127 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
37128 }
37129
37130 if (RETURN_VALUE_USED(opline)) {
37131 /* If the return value of yield is used set the send
37132 * target and initialize it to NULL */
37133 generator->send_target = EX_VAR(opline->result.var);
37134 ZVAL_NULL(generator->send_target);
37135 } else {
37136 generator->send_target = NULL;
37137 }
37138
37139 /* We increment to the next op, so we are at the correct position when the
37140 * generator is resumed. */
37141 ZEND_VM_INC_OPCODE();
37142
37143 /* The GOTO VM uses a local opline variable. We need to set the opline
37144 * variable in execute_data so we don't resume at an old position. */
37145 SAVE_OPLINE();
37146
37147 ZEND_VM_RETURN();
37148 }
37149
ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37150 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37151 {
37152 USE_OPLINE
37153
37154 if (EXPECTED(Z_TYPE(EX(This)) == IS_OBJECT)) {
37155 zval *result = EX_VAR(opline->result.var);
37156
37157 ZVAL_OBJ(result, Z_OBJ(EX(This)));
37158 Z_ADDREF_P(result);
37159 ZEND_VM_NEXT_OPCODE();
37160 } else {
37161 ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37162 }
37163 }
37164
ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37165 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37166 {
37167 USE_OPLINE
37168
37169 /* For symbol tables we need to deal with exactly the same problems as for property tables. */
37170 ZVAL_ARR(EX_VAR(opline->result.var),
37171 zend_proptable_to_symtable(&EG(symbol_table), /* always_duplicate */ 1));
37172 ZEND_VM_NEXT_OPCODE();
37173 }
37174
ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37175 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37176 {
37177 USE_OPLINE
37178
37179 ZVAL_BOOL(EX_VAR(opline->result.var),
37180 (opline->extended_value & ZEND_ISEMPTY) ^
37181 (Z_TYPE(EX(This)) == IS_OBJECT));
37182 ZEND_VM_NEXT_OPCODE();
37183 }
37184
ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37185 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37186 {
37187 USE_OPLINE
37188
37189 if (IS_UNUSED == IS_UNUSED) {
37190 SAVE_OPLINE();
37191 if (UNEXPECTED(!EX(func)->common.scope)) {
37192 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
37193 ZVAL_UNDEF(EX_VAR(opline->result.var));
37194 HANDLE_EXCEPTION();
37195 } else {
37196 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
37197 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
37198 if (UNEXPECTED(EG(exception))) {
37199 HANDLE_EXCEPTION();
37200 }
37201 ZEND_VM_NEXT_OPCODE();
37202 }
37203 } else {
37204 zval *op1;
37205
37206 SAVE_OPLINE();
37207 op1 = NULL;
37208 while (1) {
37209 if (Z_TYPE_P(op1) == IS_OBJECT) {
37210 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
37211 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
37212 op1 = Z_REFVAL_P(op1);
37213 continue;
37214 } else {
37215 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
37216 ZVAL_UNDEFINED_OP1();
37217 }
37218 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
37219 ZVAL_UNDEF(EX_VAR(opline->result.var));
37220 }
37221 break;
37222 }
37223
37224 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37225 }
37226 }
37227
ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37228 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37229 {
37230 USE_OPLINE
37231
37232 if (Z_TYPE(EX(This)) == IS_OBJECT) {
37233 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
37234 } else if (Z_CE(EX(This))) {
37235 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
37236 } else {
37237 ZEND_ASSERT(!EX(func)->common.scope);
37238 SAVE_OPLINE();
37239 zend_throw_error(NULL, "get_called_class() must be called from within a class");
37240 ZVAL_UNDEF(EX_VAR(opline->result.var));
37241 HANDLE_EXCEPTION();
37242 }
37243 ZEND_VM_NEXT_OPCODE();
37244 }
37245
ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37246 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37247 {
37248 USE_OPLINE
37249
37250 ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
37251 ZEND_VM_NEXT_OPCODE();
37252 }
37253
ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37254 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37255 {
37256 USE_OPLINE
37257 zend_array *ht;
37258 uint32_t arg_count, result_size, skip;
37259
37260 arg_count = EX_NUM_ARGS();
37261 if (IS_UNUSED == IS_CONST) {
37262 skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
37263 if (arg_count < skip) {
37264 result_size = 0;
37265 } else {
37266 result_size = arg_count - skip;
37267 }
37268 } else {
37269 skip = 0;
37270 result_size = arg_count;
37271 }
37272
37273 if (result_size) {
37274 SAVE_OPLINE();
37275 uint32_t first_extra_arg = EX(func)->op_array.num_args;
37276
37277 ht = zend_new_array(result_size);
37278 ZVAL_ARR(EX_VAR(opline->result.var), ht);
37279 zend_hash_real_init_packed(ht);
37280 ZEND_HASH_FILL_PACKED(ht) {
37281 zval *p, *q;
37282 uint32_t i = skip;
37283 p = EX_VAR_NUM(i);
37284 if (arg_count > first_extra_arg) {
37285 while (i < first_extra_arg) {
37286 q = p;
37287 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
37288 ZVAL_DEREF(q);
37289 if (Z_OPT_REFCOUNTED_P(q)) {
37290 Z_ADDREF_P(q);
37291 }
37292 ZEND_HASH_FILL_SET(q);
37293 } else {
37294 ZEND_HASH_FILL_SET_NULL();
37295 }
37296 ZEND_HASH_FILL_NEXT();
37297 p++;
37298 i++;
37299 }
37300 if (skip < first_extra_arg) {
37301 skip = 0;
37302 } else {
37303 skip -= first_extra_arg;
37304 }
37305 p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
37306 }
37307 while (i < arg_count) {
37308 q = p;
37309 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
37310 ZVAL_DEREF(q);
37311 if (Z_OPT_REFCOUNTED_P(q)) {
37312 Z_ADDREF_P(q);
37313 }
37314 ZEND_HASH_FILL_SET(q);
37315 } else {
37316 ZEND_HASH_FILL_SET_NULL();
37317 }
37318 ZEND_HASH_FILL_NEXT();
37319 p++;
37320 i++;
37321 }
37322 } ZEND_HASH_FILL_END();
37323 ht->nNumOfElements = result_size;
37324 } else {
37325 ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
37326 }
37327 ZEND_VM_NEXT_OPCODE();
37328 }
37329
37330 /* 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)37331 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37332 {
37333 USE_OPLINE
37334 zend_execute_data *call = EX(call);
37335
37336 zend_closure_from_frame(EX_VAR(opline->result.var), call);
37337
37338 if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) {
37339 OBJ_RELEASE(Z_OBJ(call->This));
37340 }
37341
37342 EX(call) = call->prev_execute_data;
37343
37344 zend_vm_stack_free_call_frame(call);
37345
37346 ZEND_VM_NEXT_OPCODE();
37347 }
37348
ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37349 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37350 {
37351 USE_OPLINE
37352 SAVE_OPLINE();
37353 zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline);
37354 ZVAL_NULL(EX_VAR(opline->result.var));
37355 function(EX_VAR(opline->result.var));
37356 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37357 }
37358
ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37359 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37360 {
37361 USE_OPLINE
37362 zval *object;
37363 zval *property;
37364 zval *value;
37365 zval *zptr;
37366 void **cache_slot;
37367 zend_property_info *prop_info;
37368 zend_object *zobj;
37369 zend_string *name, *tmp_name;
37370
37371 SAVE_OPLINE();
37372 object = &EX(This);
37373 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37374
37375 do {
37376 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
37377
37378 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
37379 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
37380 object = Z_REFVAL_P(object);
37381 goto assign_op_object;
37382 }
37383 if (IS_UNUSED == IS_CV
37384 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
37385 ZVAL_UNDEFINED_OP1();
37386 }
37387 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
37388 break;
37389 }
37390
37391 assign_op_object:
37392 /* here we are sure we are dealing with an object */
37393 zobj = Z_OBJ_P(object);
37394 if (IS_CV == IS_CONST) {
37395 name = Z_STR_P(property);
37396 } else {
37397 name = zval_try_get_tmp_string(property, &tmp_name);
37398 if (UNEXPECTED(!name)) {
37399 UNDEF_RESULT();
37400 break;
37401 }
37402 }
37403 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
37404 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
37405 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
37406 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
37407 ZVAL_NULL(EX_VAR(opline->result.var));
37408 }
37409 } else {
37410 zval *orig_zptr = zptr;
37411 zend_reference *ref;
37412
37413 do {
37414 if (UNEXPECTED(Z_ISREF_P(zptr))) {
37415 ref = Z_REF_P(zptr);
37416 zptr = Z_REFVAL_P(zptr);
37417 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
37418 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
37419 break;
37420 }
37421 }
37422
37423 if (IS_CV == IS_CONST) {
37424 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
37425 } else {
37426 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
37427 }
37428 if (prop_info) {
37429 /* special case for typed properties */
37430 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
37431 } else {
37432 zend_binary_op(zptr, zptr, value OPLINE_CC);
37433 }
37434 } while (0);
37435
37436 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
37437 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
37438 }
37439 }
37440 } else {
37441 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
37442 }
37443 if (IS_CV != IS_CONST) {
37444 zend_tmp_string_release(tmp_name);
37445 }
37446 } while (0);
37447
37448 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
37449
37450
37451 /* assign_obj has two opcodes! */
37452 ZEND_VM_NEXT_OPCODE_EX(1, 2);
37453 }
37454
37455 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37456 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37457 {
37458 USE_OPLINE
37459 zval *object;
37460 zval *property;
37461 zval *zptr;
37462 void **cache_slot;
37463 zend_property_info *prop_info;
37464 zend_object *zobj;
37465 zend_string *name, *tmp_name;
37466
37467 SAVE_OPLINE();
37468 object = &EX(This);
37469 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37470
37471 do {
37472 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
37473 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
37474 object = Z_REFVAL_P(object);
37475 goto pre_incdec_object;
37476 }
37477 if (IS_UNUSED == IS_CV
37478 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
37479 ZVAL_UNDEFINED_OP1();
37480 }
37481 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
37482 break;
37483 }
37484
37485 pre_incdec_object:
37486 /* here we are sure we are dealing with an object */
37487 zobj = Z_OBJ_P(object);
37488 if (IS_CV == IS_CONST) {
37489 name = Z_STR_P(property);
37490 } else {
37491 name = zval_try_get_tmp_string(property, &tmp_name);
37492 if (UNEXPECTED(!name)) {
37493 UNDEF_RESULT();
37494 break;
37495 }
37496 }
37497 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
37498 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
37499 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
37500 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
37501 ZVAL_NULL(EX_VAR(opline->result.var));
37502 }
37503 } else {
37504 if (IS_CV == IS_CONST) {
37505 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
37506 } else {
37507 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
37508 }
37509 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
37510 }
37511 } else {
37512 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
37513 }
37514 if (IS_CV != IS_CONST) {
37515 zend_tmp_string_release(tmp_name);
37516 }
37517 } while (0);
37518
37519
37520 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37521 }
37522
ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37523 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37524 {
37525 USE_OPLINE
37526 zval *object;
37527 zval *property;
37528 zval *zptr;
37529 void **cache_slot;
37530 zend_property_info *prop_info;
37531 zend_object *zobj;
37532 zend_string *name, *tmp_name;
37533
37534 SAVE_OPLINE();
37535 object = &EX(This);
37536 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37537
37538 do {
37539 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
37540 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
37541 object = Z_REFVAL_P(object);
37542 goto post_incdec_object;
37543 }
37544 if (IS_UNUSED == IS_CV
37545 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
37546 ZVAL_UNDEFINED_OP1();
37547 }
37548 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
37549 break;
37550 }
37551
37552 post_incdec_object:
37553 /* here we are sure we are dealing with an object */
37554 zobj = Z_OBJ_P(object);
37555 if (IS_CV == IS_CONST) {
37556 name = Z_STR_P(property);
37557 } else {
37558 name = zval_try_get_tmp_string(property, &tmp_name);
37559 if (UNEXPECTED(!name)) {
37560 ZVAL_UNDEF(EX_VAR(opline->result.var));
37561 break;
37562 }
37563 }
37564 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
37565 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
37566 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
37567 ZVAL_NULL(EX_VAR(opline->result.var));
37568 } else {
37569 if (IS_CV == IS_CONST) {
37570 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
37571 } else {
37572 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
37573 }
37574
37575 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
37576 }
37577 } else {
37578 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
37579 }
37580 if (IS_CV != IS_CONST) {
37581 zend_tmp_string_release(tmp_name);
37582 }
37583 } while (0);
37584
37585
37586 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37587 }
37588
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37589 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37590 {
37591 USE_OPLINE
37592 zval *container;
37593 void **cache_slot = NULL;
37594
37595 SAVE_OPLINE();
37596 container = &EX(This);
37597
37598 if (IS_UNUSED == IS_CONST ||
37599 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
37600 do {
37601 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
37602 container = Z_REFVAL_P(container);
37603 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
37604 break;
37605 }
37606 }
37607 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
37608 ZVAL_UNDEFINED_OP1();
37609 }
37610 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37611 ZVAL_NULL(EX_VAR(opline->result.var));
37612 goto fetch_obj_r_finish;
37613 } while (0);
37614 }
37615
37616 /* here we are sure we are dealing with an object */
37617 do {
37618 zend_object *zobj = Z_OBJ_P(container);
37619 zend_string *name, *tmp_name;
37620 zval *retval;
37621
37622 if (IS_CV == IS_CONST) {
37623 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
37624
37625 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
37626 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
37627
37628 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
37629 retval = OBJ_PROP(zobj, prop_offset);
37630 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
37631 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37632 goto fetch_obj_r_copy;
37633 } else {
37634 fetch_obj_r_fast_copy:
37635 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
37636 ZEND_VM_NEXT_OPCODE();
37637 }
37638 }
37639 } else if (EXPECTED(zobj->properties != NULL)) {
37640 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37641 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
37642 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
37643
37644 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
37645 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
37646
37647 if (EXPECTED(p->key == name) ||
37648 (EXPECTED(p->h == ZSTR_H(name)) &&
37649 EXPECTED(p->key != NULL) &&
37650 EXPECTED(zend_string_equal_content(p->key, name)))) {
37651 retval = &p->val;
37652 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37653 goto fetch_obj_r_copy;
37654 } else {
37655 goto fetch_obj_r_fast_copy;
37656 }
37657 }
37658 }
37659 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
37660 }
37661 retval = zend_hash_find_known_hash(zobj->properties, name);
37662 if (EXPECTED(retval)) {
37663 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
37664 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
37665 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37666 goto fetch_obj_r_copy;
37667 } else {
37668 goto fetch_obj_r_fast_copy;
37669 }
37670 }
37671 }
37672 }
37673 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37674 } else {
37675 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
37676 if (UNEXPECTED(!name)) {
37677 ZVAL_UNDEF(EX_VAR(opline->result.var));
37678 break;
37679 }
37680 }
37681
37682 #if ZEND_DEBUG
37683 /* For non-standard object handlers, verify a declared property type in debug builds.
37684 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
37685 zend_property_info *prop_info = NULL;
37686 if (zobj->handlers->read_property != zend_std_read_property) {
37687 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
37688 }
37689 #endif
37690 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
37691 #if ZEND_DEBUG
37692 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
37693 && ZEND_TYPE_IS_SET(prop_info->type)) {
37694 ZVAL_OPT_DEREF(retval);
37695 zend_verify_property_type(prop_info, retval, /* strict */ true);
37696 }
37697 #endif
37698
37699 if (IS_CV != IS_CONST) {
37700 zend_tmp_string_release(tmp_name);
37701 }
37702
37703 if (retval != EX_VAR(opline->result.var)) {
37704 fetch_obj_r_copy:
37705 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
37706 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
37707 zend_unwrap_reference(retval);
37708 }
37709 } while (0);
37710
37711 fetch_obj_r_finish:
37712
37713
37714 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37715 }
37716
ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37717 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37718 {
37719 USE_OPLINE
37720 zval *property, *container, *result;
37721
37722 SAVE_OPLINE();
37723
37724 container = &EX(This);
37725 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37726 result = EX_VAR(opline->result.var);
37727 zend_fetch_property_address(
37728 result, container, IS_UNUSED, property, IS_CV,
37729 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
37730 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
37731
37732 if (IS_UNUSED == IS_VAR) {
37733 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
37734 }
37735 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37736 }
37737
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37738 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37739 {
37740 USE_OPLINE
37741 zval *property, *container, *result;
37742
37743 SAVE_OPLINE();
37744 container = &EX(This);
37745 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37746 result = EX_VAR(opline->result.var);
37747 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);
37748
37749 if (IS_UNUSED == IS_VAR) {
37750 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
37751 }
37752 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37753 }
37754
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37755 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37756 {
37757 USE_OPLINE
37758 zval *container;
37759 void **cache_slot = NULL;
37760
37761 SAVE_OPLINE();
37762 container = &EX(This);
37763
37764 if (IS_UNUSED == IS_CONST ||
37765 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
37766 do {
37767 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
37768 container = Z_REFVAL_P(container);
37769 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
37770 break;
37771 }
37772 }
37773 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
37774 ZVAL_UNDEFINED_OP2();
37775 }
37776 ZVAL_NULL(EX_VAR(opline->result.var));
37777 goto fetch_obj_is_finish;
37778 } while (0);
37779 }
37780
37781 /* here we are sure we are dealing with an object */
37782 do {
37783 zend_object *zobj = Z_OBJ_P(container);
37784 zend_string *name, *tmp_name;
37785 zval *retval;
37786
37787 if (IS_CV == IS_CONST) {
37788 cache_slot = CACHE_ADDR(opline->extended_value);
37789
37790 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
37791 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
37792
37793 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
37794 retval = OBJ_PROP(zobj, prop_offset);
37795 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
37796 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37797 goto fetch_obj_is_copy;
37798 } else {
37799 fetch_obj_is_fast_copy:
37800 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
37801 ZEND_VM_NEXT_OPCODE();
37802 }
37803 }
37804 } else if (EXPECTED(zobj->properties != NULL)) {
37805 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37806 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
37807 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
37808
37809 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
37810 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
37811
37812 if (EXPECTED(p->key == name) ||
37813 (EXPECTED(p->h == ZSTR_H(name)) &&
37814 EXPECTED(p->key != NULL) &&
37815 EXPECTED(zend_string_equal_content(p->key, name)))) {
37816 retval = &p->val;
37817 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37818 goto fetch_obj_is_copy;
37819 } else {
37820 goto fetch_obj_is_fast_copy;
37821 }
37822 }
37823 }
37824 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
37825 }
37826 retval = zend_hash_find_known_hash(zobj->properties, name);
37827 if (EXPECTED(retval)) {
37828 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
37829 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
37830 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37831 goto fetch_obj_is_copy;
37832 } else {
37833 goto fetch_obj_is_fast_copy;
37834 }
37835 }
37836 }
37837 }
37838 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37839 } else {
37840 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
37841 if (UNEXPECTED(!name)) {
37842 ZVAL_UNDEF(EX_VAR(opline->result.var));
37843 break;
37844 }
37845 }
37846
37847 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
37848
37849 if (IS_CV != IS_CONST) {
37850 zend_tmp_string_release(tmp_name);
37851 }
37852
37853 if (retval != EX_VAR(opline->result.var)) {
37854 fetch_obj_is_copy:
37855 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
37856 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
37857 zend_unwrap_reference(retval);
37858 }
37859 } while (0);
37860
37861 fetch_obj_is_finish:
37862
37863
37864 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37865 }
37866
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37867 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37868 {
37869 #if 0
37870 USE_OPLINE
37871 #endif
37872
37873 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
37874 /* Behave like FETCH_OBJ_W */
37875 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
37876 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37877 }
37878 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37879 } else {
37880 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37881 }
37882 }
37883
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37884 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37885 {
37886 USE_OPLINE
37887 zval *container, *property, *result;
37888
37889 SAVE_OPLINE();
37890 container = &EX(This);
37891 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37892 result = EX_VAR(opline->result.var);
37893 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);
37894
37895 if (IS_UNUSED == IS_VAR) {
37896 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
37897 }
37898 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37899 }
37900
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37901 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37902 {
37903 USE_OPLINE
37904 zval *object, *value, tmp;
37905 zend_object *zobj;
37906 zend_string *name, *tmp_name;
37907 zend_refcounted *garbage = NULL;
37908
37909 SAVE_OPLINE();
37910 object = &EX(This);
37911 value = RT_CONSTANT((opline+1), (opline+1)->op1);
37912
37913 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
37914 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
37915 object = Z_REFVAL_P(object);
37916 goto assign_object;
37917 }
37918 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
37919 value = &EG(uninitialized_zval);
37920 goto free_and_exit_assign_obj;
37921 }
37922
37923 assign_object:
37924 zobj = Z_OBJ_P(object);
37925 if (IS_CV == IS_CONST) {
37926 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
37927 void **cache_slot = CACHE_ADDR(opline->extended_value);
37928 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
37929 zval *property_val;
37930
37931 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
37932 property_val = OBJ_PROP(zobj, prop_offset);
37933 if (Z_TYPE_P(property_val) != IS_UNDEF) {
37934 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
37935
37936 if (prop_info != NULL) {
37937 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
37938 goto free_and_exit_assign_obj;
37939 } else {
37940 fast_assign_obj:
37941 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
37942 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
37943 ZVAL_COPY(EX_VAR(opline->result.var), value);
37944 }
37945 goto exit_assign_obj;
37946 }
37947 }
37948 } else {
37949 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37950 if (EXPECTED(zobj->properties != NULL)) {
37951 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
37952 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
37953 GC_DELREF(zobj->properties);
37954 }
37955 zobj->properties = zend_array_dup(zobj->properties);
37956 }
37957 property_val = zend_hash_find_known_hash(zobj->properties, name);
37958 if (property_val) {
37959 goto fast_assign_obj;
37960 }
37961 }
37962
37963 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
37964 if (EXPECTED(zobj->properties == NULL)) {
37965 rebuild_object_properties(zobj);
37966 }
37967 if (IS_CONST == IS_CONST) {
37968 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
37969 Z_ADDREF_P(value);
37970 }
37971 } else if (IS_CONST != IS_TMP_VAR) {
37972 if (Z_ISREF_P(value)) {
37973 if (IS_CONST == IS_VAR) {
37974 zend_reference *ref = Z_REF_P(value);
37975 if (GC_DELREF(ref) == 0) {
37976 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
37977 efree_size(ref, sizeof(zend_reference));
37978 value = &tmp;
37979 } else {
37980 value = Z_REFVAL_P(value);
37981 Z_TRY_ADDREF_P(value);
37982 }
37983 } else {
37984 value = Z_REFVAL_P(value);
37985 Z_TRY_ADDREF_P(value);
37986 }
37987 } else if (IS_CONST == IS_CV) {
37988 Z_TRY_ADDREF_P(value);
37989 }
37990 }
37991 zend_hash_add_new(zobj->properties, name, value);
37992 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
37993 ZVAL_COPY(EX_VAR(opline->result.var), value);
37994 }
37995 goto exit_assign_obj;
37996 }
37997 }
37998 }
37999 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38000 } else {
38001 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38002 if (UNEXPECTED(!name)) {
38003
38004 UNDEF_RESULT();
38005 goto exit_assign_obj;
38006 }
38007 }
38008
38009 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
38010 ZVAL_DEREF(value);
38011 }
38012
38013 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
38014
38015 if (IS_CV != IS_CONST) {
38016 zend_tmp_string_release(tmp_name);
38017 }
38018
38019 free_and_exit_assign_obj:
38020 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
38021 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
38022 }
38023
38024 exit_assign_obj:
38025 if (garbage) {
38026 GC_DTOR_NO_REF(garbage);
38027 }
38028
38029
38030 /* assign_obj has two opcodes! */
38031 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38032 }
38033
38034 /* 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)38035 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38036 {
38037 USE_OPLINE
38038 zval *object, *value, tmp;
38039 zend_object *zobj;
38040 zend_string *name, *tmp_name;
38041 zend_refcounted *garbage = NULL;
38042
38043 SAVE_OPLINE();
38044 object = &EX(This);
38045 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
38046
38047 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38048 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38049 object = Z_REFVAL_P(object);
38050 goto assign_object;
38051 }
38052 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
38053 value = &EG(uninitialized_zval);
38054 goto free_and_exit_assign_obj;
38055 }
38056
38057 assign_object:
38058 zobj = Z_OBJ_P(object);
38059 if (IS_CV == IS_CONST) {
38060 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
38061 void **cache_slot = CACHE_ADDR(opline->extended_value);
38062 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38063 zval *property_val;
38064
38065 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38066 property_val = OBJ_PROP(zobj, prop_offset);
38067 if (Z_TYPE_P(property_val) != IS_UNDEF) {
38068 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
38069
38070 if (prop_info != NULL) {
38071 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
38072 goto free_and_exit_assign_obj;
38073 } else {
38074 fast_assign_obj:
38075 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
38076 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38077 ZVAL_COPY(EX_VAR(opline->result.var), value);
38078 }
38079 goto exit_assign_obj;
38080 }
38081 }
38082 } else {
38083 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38084 if (EXPECTED(zobj->properties != NULL)) {
38085 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
38086 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
38087 GC_DELREF(zobj->properties);
38088 }
38089 zobj->properties = zend_array_dup(zobj->properties);
38090 }
38091 property_val = zend_hash_find_known_hash(zobj->properties, name);
38092 if (property_val) {
38093 goto fast_assign_obj;
38094 }
38095 }
38096
38097 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
38098 if (EXPECTED(zobj->properties == NULL)) {
38099 rebuild_object_properties(zobj);
38100 }
38101 if (IS_TMP_VAR == IS_CONST) {
38102 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
38103 Z_ADDREF_P(value);
38104 }
38105 } else if (IS_TMP_VAR != IS_TMP_VAR) {
38106 if (Z_ISREF_P(value)) {
38107 if (IS_TMP_VAR == IS_VAR) {
38108 zend_reference *ref = Z_REF_P(value);
38109 if (GC_DELREF(ref) == 0) {
38110 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
38111 efree_size(ref, sizeof(zend_reference));
38112 value = &tmp;
38113 } else {
38114 value = Z_REFVAL_P(value);
38115 Z_TRY_ADDREF_P(value);
38116 }
38117 } else {
38118 value = Z_REFVAL_P(value);
38119 Z_TRY_ADDREF_P(value);
38120 }
38121 } else if (IS_TMP_VAR == IS_CV) {
38122 Z_TRY_ADDREF_P(value);
38123 }
38124 }
38125 zend_hash_add_new(zobj->properties, name, value);
38126 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38127 ZVAL_COPY(EX_VAR(opline->result.var), value);
38128 }
38129 goto exit_assign_obj;
38130 }
38131 }
38132 }
38133 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38134 } else {
38135 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38136 if (UNEXPECTED(!name)) {
38137 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
38138 UNDEF_RESULT();
38139 goto exit_assign_obj;
38140 }
38141 }
38142
38143 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
38144 ZVAL_DEREF(value);
38145 }
38146
38147 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
38148
38149 if (IS_CV != IS_CONST) {
38150 zend_tmp_string_release(tmp_name);
38151 }
38152
38153 free_and_exit_assign_obj:
38154 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
38155 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
38156 }
38157 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
38158 exit_assign_obj:
38159 if (garbage) {
38160 GC_DTOR_NO_REF(garbage);
38161 }
38162
38163
38164 /* assign_obj has two opcodes! */
38165 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38166 }
38167
38168 /* 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)38169 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38170 {
38171 USE_OPLINE
38172 zval *object, *value, tmp;
38173 zend_object *zobj;
38174 zend_string *name, *tmp_name;
38175 zend_refcounted *garbage = NULL;
38176
38177 SAVE_OPLINE();
38178 object = &EX(This);
38179 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
38180
38181 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38182 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38183 object = Z_REFVAL_P(object);
38184 goto assign_object;
38185 }
38186 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
38187 value = &EG(uninitialized_zval);
38188 goto free_and_exit_assign_obj;
38189 }
38190
38191 assign_object:
38192 zobj = Z_OBJ_P(object);
38193 if (IS_CV == IS_CONST) {
38194 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
38195 void **cache_slot = CACHE_ADDR(opline->extended_value);
38196 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38197 zval *property_val;
38198
38199 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38200 property_val = OBJ_PROP(zobj, prop_offset);
38201 if (Z_TYPE_P(property_val) != IS_UNDEF) {
38202 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
38203
38204 if (prop_info != NULL) {
38205 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
38206 goto free_and_exit_assign_obj;
38207 } else {
38208 fast_assign_obj:
38209 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
38210 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38211 ZVAL_COPY(EX_VAR(opline->result.var), value);
38212 }
38213 goto exit_assign_obj;
38214 }
38215 }
38216 } else {
38217 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38218 if (EXPECTED(zobj->properties != NULL)) {
38219 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
38220 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
38221 GC_DELREF(zobj->properties);
38222 }
38223 zobj->properties = zend_array_dup(zobj->properties);
38224 }
38225 property_val = zend_hash_find_known_hash(zobj->properties, name);
38226 if (property_val) {
38227 goto fast_assign_obj;
38228 }
38229 }
38230
38231 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
38232 if (EXPECTED(zobj->properties == NULL)) {
38233 rebuild_object_properties(zobj);
38234 }
38235 if (IS_VAR == IS_CONST) {
38236 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
38237 Z_ADDREF_P(value);
38238 }
38239 } else if (IS_VAR != IS_TMP_VAR) {
38240 if (Z_ISREF_P(value)) {
38241 if (IS_VAR == IS_VAR) {
38242 zend_reference *ref = Z_REF_P(value);
38243 if (GC_DELREF(ref) == 0) {
38244 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
38245 efree_size(ref, sizeof(zend_reference));
38246 value = &tmp;
38247 } else {
38248 value = Z_REFVAL_P(value);
38249 Z_TRY_ADDREF_P(value);
38250 }
38251 } else {
38252 value = Z_REFVAL_P(value);
38253 Z_TRY_ADDREF_P(value);
38254 }
38255 } else if (IS_VAR == IS_CV) {
38256 Z_TRY_ADDREF_P(value);
38257 }
38258 }
38259 zend_hash_add_new(zobj->properties, name, value);
38260 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38261 ZVAL_COPY(EX_VAR(opline->result.var), value);
38262 }
38263 goto exit_assign_obj;
38264 }
38265 }
38266 }
38267 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38268 } else {
38269 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38270 if (UNEXPECTED(!name)) {
38271 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
38272 UNDEF_RESULT();
38273 goto exit_assign_obj;
38274 }
38275 }
38276
38277 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
38278 ZVAL_DEREF(value);
38279 }
38280
38281 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
38282
38283 if (IS_CV != IS_CONST) {
38284 zend_tmp_string_release(tmp_name);
38285 }
38286
38287 free_and_exit_assign_obj:
38288 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
38289 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
38290 }
38291 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
38292 exit_assign_obj:
38293 if (garbage) {
38294 GC_DTOR_NO_REF(garbage);
38295 }
38296
38297
38298 /* assign_obj has two opcodes! */
38299 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38300 }
38301
38302 /* 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)38303 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38304 {
38305 USE_OPLINE
38306 zval *object, *value, tmp;
38307 zend_object *zobj;
38308 zend_string *name, *tmp_name;
38309 zend_refcounted *garbage = NULL;
38310
38311 SAVE_OPLINE();
38312 object = &EX(This);
38313 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
38314
38315 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38316 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38317 object = Z_REFVAL_P(object);
38318 goto assign_object;
38319 }
38320 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
38321 value = &EG(uninitialized_zval);
38322 goto free_and_exit_assign_obj;
38323 }
38324
38325 assign_object:
38326 zobj = Z_OBJ_P(object);
38327 if (IS_CV == IS_CONST) {
38328 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
38329 void **cache_slot = CACHE_ADDR(opline->extended_value);
38330 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38331 zval *property_val;
38332
38333 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38334 property_val = OBJ_PROP(zobj, prop_offset);
38335 if (Z_TYPE_P(property_val) != IS_UNDEF) {
38336 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
38337
38338 if (prop_info != NULL) {
38339 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
38340 goto free_and_exit_assign_obj;
38341 } else {
38342 fast_assign_obj:
38343 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
38344 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38345 ZVAL_COPY(EX_VAR(opline->result.var), value);
38346 }
38347 goto exit_assign_obj;
38348 }
38349 }
38350 } else {
38351 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38352 if (EXPECTED(zobj->properties != NULL)) {
38353 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
38354 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
38355 GC_DELREF(zobj->properties);
38356 }
38357 zobj->properties = zend_array_dup(zobj->properties);
38358 }
38359 property_val = zend_hash_find_known_hash(zobj->properties, name);
38360 if (property_val) {
38361 goto fast_assign_obj;
38362 }
38363 }
38364
38365 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
38366 if (EXPECTED(zobj->properties == NULL)) {
38367 rebuild_object_properties(zobj);
38368 }
38369 if (IS_CV == IS_CONST) {
38370 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
38371 Z_ADDREF_P(value);
38372 }
38373 } else if (IS_CV != IS_TMP_VAR) {
38374 if (Z_ISREF_P(value)) {
38375 if (IS_CV == IS_VAR) {
38376 zend_reference *ref = Z_REF_P(value);
38377 if (GC_DELREF(ref) == 0) {
38378 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
38379 efree_size(ref, sizeof(zend_reference));
38380 value = &tmp;
38381 } else {
38382 value = Z_REFVAL_P(value);
38383 Z_TRY_ADDREF_P(value);
38384 }
38385 } else {
38386 value = Z_REFVAL_P(value);
38387 Z_TRY_ADDREF_P(value);
38388 }
38389 } else if (IS_CV == IS_CV) {
38390 Z_TRY_ADDREF_P(value);
38391 }
38392 }
38393 zend_hash_add_new(zobj->properties, name, value);
38394 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38395 ZVAL_COPY(EX_VAR(opline->result.var), value);
38396 }
38397 goto exit_assign_obj;
38398 }
38399 }
38400 }
38401 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38402 } else {
38403 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38404 if (UNEXPECTED(!name)) {
38405
38406 UNDEF_RESULT();
38407 goto exit_assign_obj;
38408 }
38409 }
38410
38411 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
38412 ZVAL_DEREF(value);
38413 }
38414
38415 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
38416
38417 if (IS_CV != IS_CONST) {
38418 zend_tmp_string_release(tmp_name);
38419 }
38420
38421 free_and_exit_assign_obj:
38422 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
38423 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
38424 }
38425
38426 exit_assign_obj:
38427 if (garbage) {
38428 GC_DTOR_NO_REF(garbage);
38429 }
38430
38431
38432 /* assign_obj has two opcodes! */
38433 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38434 }
38435
38436 /* 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)38437 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38438 {
38439 USE_OPLINE
38440 zval *property, *container, *value_ptr;
38441
38442 SAVE_OPLINE();
38443
38444 container = &EX(This);
38445 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38446
38447 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
38448
38449 if (1) {
38450 if (IS_UNUSED == IS_UNUSED) {
38451 if (IS_CV == IS_CONST) {
38452 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38453 } else {
38454 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38455 }
38456 } else {
38457 if (IS_CV == IS_CONST) {
38458 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38459 } else {
38460 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38461 }
38462 }
38463 } else {
38464 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38465 }
38466
38467
38468 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
38469 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38470 }
38471
38472 /* 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)38473 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38474 {
38475 USE_OPLINE
38476 zval *property, *container, *value_ptr;
38477
38478 SAVE_OPLINE();
38479
38480 container = &EX(This);
38481 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38482
38483 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
38484
38485 if (1) {
38486 if (IS_UNUSED == IS_UNUSED) {
38487 if (IS_CV == IS_CONST) {
38488 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38489 } else {
38490 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38491 }
38492 } else {
38493 if (IS_CV == IS_CONST) {
38494 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38495 } else {
38496 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38497 }
38498 }
38499 } else {
38500 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38501 }
38502
38503
38504
38505 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38506 }
38507
38508 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38509 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38510 {
38511 USE_OPLINE
38512 zend_string **rope;
38513 zval *var;
38514
38515 /* Compiler allocates the necessary number of zval slots to keep the rope */
38516 rope = (zend_string**)EX_VAR(opline->result.var);
38517 if (IS_CV == IS_CONST) {
38518 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38519 rope[0] = Z_STR_P(var);
38520 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
38521 Z_ADDREF_P(var);
38522 }
38523 } else {
38524 var = EX_VAR(opline->op2.var);
38525 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
38526 if (IS_CV == IS_CV) {
38527 rope[0] = zend_string_copy(Z_STR_P(var));
38528 } else {
38529 rope[0] = Z_STR_P(var);
38530 }
38531 } else {
38532 SAVE_OPLINE();
38533 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
38534 ZVAL_UNDEFINED_OP2();
38535 }
38536 rope[0] = zval_get_string_func(var);
38537
38538 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38539 }
38540 }
38541 ZEND_VM_NEXT_OPCODE();
38542 }
38543
ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38544 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38545 {
38546 zval *class_name;
38547 USE_OPLINE
38548
38549 SAVE_OPLINE();
38550 if (IS_CV == IS_UNUSED) {
38551 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
38552 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38553 } else if (IS_CV == IS_CONST) {
38554 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
38555
38556 if (UNEXPECTED(ce == NULL)) {
38557 class_name = EX_VAR(opline->op2.var);
38558 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
38559 CACHE_PTR(opline->extended_value, ce);
38560 }
38561 Z_CE_P(EX_VAR(opline->result.var)) = ce;
38562 } else {
38563 class_name = EX_VAR(opline->op2.var);
38564 try_class_name:
38565 if (Z_TYPE_P(class_name) == IS_OBJECT) {
38566 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
38567 } else if (Z_TYPE_P(class_name) == IS_STRING) {
38568 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
38569 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
38570 class_name = Z_REFVAL_P(class_name);
38571 goto try_class_name;
38572 } else {
38573 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
38574 ZVAL_UNDEFINED_OP2();
38575 if (UNEXPECTED(EG(exception) != NULL)) {
38576 HANDLE_EXCEPTION();
38577 }
38578 }
38579 zend_throw_error(NULL, "Class name must be a valid object or a string");
38580 }
38581 }
38582
38583 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38584 }
38585
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38586 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38587 {
38588 USE_OPLINE
38589 zval *function_name;
38590 zval *object;
38591 zend_function *fbc;
38592 zend_class_entry *called_scope;
38593 zend_object *obj;
38594 zend_execute_data *call;
38595 uint32_t call_info;
38596
38597 SAVE_OPLINE();
38598
38599 object = &EX(This);
38600
38601 if (IS_CV != IS_CONST) {
38602 function_name = EX_VAR(opline->op2.var);
38603 }
38604
38605 if (IS_CV != IS_CONST &&
38606 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
38607 do {
38608 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
38609 function_name = Z_REFVAL_P(function_name);
38610 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
38611 break;
38612 }
38613 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
38614 ZVAL_UNDEFINED_OP2();
38615 if (UNEXPECTED(EG(exception) != NULL)) {
38616
38617 HANDLE_EXCEPTION();
38618 }
38619 }
38620 zend_throw_error(NULL, "Method name must be a string");
38621
38622
38623 HANDLE_EXCEPTION();
38624 } while (0);
38625 }
38626
38627 if (IS_UNUSED == IS_UNUSED) {
38628 obj = Z_OBJ_P(object);
38629 } else {
38630 do {
38631 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
38632 obj = Z_OBJ_P(object);
38633 } else {
38634 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
38635 zend_reference *ref = Z_REF_P(object);
38636
38637 object = &ref->val;
38638 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
38639 obj = Z_OBJ_P(object);
38640 if (IS_UNUSED & IS_VAR) {
38641 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
38642 efree_size(ref, sizeof(zend_reference));
38643 } else {
38644 Z_ADDREF_P(object);
38645 }
38646 }
38647 break;
38648 }
38649 }
38650 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38651 object = ZVAL_UNDEFINED_OP1();
38652 if (UNEXPECTED(EG(exception) != NULL)) {
38653 if (IS_CV != IS_CONST) {
38654
38655 }
38656 HANDLE_EXCEPTION();
38657 }
38658 }
38659 if (IS_CV == IS_CONST) {
38660 function_name = EX_VAR(opline->op2.var);
38661 }
38662 zend_invalid_method_call(object, function_name);
38663
38664
38665 HANDLE_EXCEPTION();
38666 }
38667 } while (0);
38668 }
38669
38670 called_scope = obj->ce;
38671
38672 if (IS_CV == IS_CONST &&
38673 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
38674 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
38675 } else {
38676 zend_object *orig_obj = obj;
38677
38678 if (IS_CV == IS_CONST) {
38679 function_name = EX_VAR(opline->op2.var);
38680 }
38681
38682 /* First, locate the function. */
38683 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
38684 if (UNEXPECTED(fbc == NULL)) {
38685 if (EXPECTED(!EG(exception))) {
38686 zend_undefined_method(obj->ce, Z_STR_P(function_name));
38687 }
38688
38689 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
38690 zend_objects_store_del(orig_obj);
38691 }
38692 HANDLE_EXCEPTION();
38693 }
38694 if (IS_CV == IS_CONST &&
38695 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
38696 EXPECTED(obj == orig_obj)) {
38697 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
38698 }
38699 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
38700 GC_ADDREF(obj); /* For $this pointer */
38701 if (GC_DELREF(orig_obj) == 0) {
38702 zend_objects_store_del(orig_obj);
38703 }
38704 }
38705 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
38706 init_func_run_time_cache(&fbc->op_array);
38707 }
38708 }
38709
38710 if (IS_CV != IS_CONST) {
38711
38712 }
38713
38714 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
38715 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
38716 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
38717 zend_objects_store_del(obj);
38718 if (UNEXPECTED(EG(exception))) {
38719 HANDLE_EXCEPTION();
38720 }
38721 }
38722 /* call static method */
38723 obj = (zend_object*)called_scope;
38724 call_info = ZEND_CALL_NESTED_FUNCTION;
38725 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
38726 if (IS_UNUSED == IS_CV) {
38727 GC_ADDREF(obj); /* For $this pointer */
38728 }
38729 /* CV may be changed indirectly (e.g. when it's a reference) */
38730 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
38731 }
38732
38733 call = zend_vm_stack_push_call_frame(call_info,
38734 fbc, opline->extended_value, obj);
38735 call->prev_execute_data = EX(call);
38736 EX(call) = call;
38737
38738 ZEND_VM_NEXT_OPCODE();
38739 }
38740
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38741 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38742 {
38743 USE_OPLINE
38744 zval *function_name;
38745 zend_class_entry *ce;
38746 uint32_t call_info;
38747 zend_function *fbc;
38748 zend_execute_data *call;
38749
38750 SAVE_OPLINE();
38751
38752 if (IS_UNUSED == IS_CONST) {
38753 /* no function found. try a static method in class */
38754 ce = CACHED_PTR(opline->result.num);
38755 if (UNEXPECTED(ce == NULL)) {
38756 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);
38757 if (UNEXPECTED(ce == NULL)) {
38758
38759 HANDLE_EXCEPTION();
38760 }
38761 if (IS_CV != IS_CONST) {
38762 CACHE_PTR(opline->result.num, ce);
38763 }
38764 }
38765 } else if (IS_UNUSED == IS_UNUSED) {
38766 ce = zend_fetch_class(NULL, opline->op1.num);
38767 if (UNEXPECTED(ce == NULL)) {
38768
38769 HANDLE_EXCEPTION();
38770 }
38771 } else {
38772 ce = Z_CE_P(EX_VAR(opline->op1.var));
38773 }
38774
38775 if (IS_UNUSED == IS_CONST &&
38776 IS_CV == IS_CONST &&
38777 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
38778 /* nothing to do */
38779 } else if (IS_UNUSED != IS_CONST &&
38780 IS_CV == IS_CONST &&
38781 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
38782 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
38783 } else if (IS_CV != IS_UNUSED) {
38784 function_name = EX_VAR(opline->op2.var);
38785 if (IS_CV != IS_CONST) {
38786 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
38787 do {
38788 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
38789 function_name = Z_REFVAL_P(function_name);
38790 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
38791 break;
38792 }
38793 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
38794 ZVAL_UNDEFINED_OP2();
38795 if (UNEXPECTED(EG(exception) != NULL)) {
38796 HANDLE_EXCEPTION();
38797 }
38798 }
38799 zend_throw_error(NULL, "Method name must be a string");
38800
38801 HANDLE_EXCEPTION();
38802 } while (0);
38803 }
38804 }
38805
38806 if (ce->get_static_method) {
38807 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
38808 } else {
38809 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
38810 }
38811 if (UNEXPECTED(fbc == NULL)) {
38812 if (EXPECTED(!EG(exception))) {
38813 zend_undefined_method(ce, Z_STR_P(function_name));
38814 }
38815
38816 HANDLE_EXCEPTION();
38817 }
38818 if (IS_CV == IS_CONST &&
38819 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
38820 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
38821 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
38822 }
38823 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
38824 init_func_run_time_cache(&fbc->op_array);
38825 }
38826 if (IS_CV != IS_CONST) {
38827
38828 }
38829 } else {
38830 if (UNEXPECTED(ce->constructor == NULL)) {
38831 zend_throw_error(NULL, "Cannot call constructor");
38832 HANDLE_EXCEPTION();
38833 }
38834 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
38835 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
38836 HANDLE_EXCEPTION();
38837 }
38838 fbc = ce->constructor;
38839 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
38840 init_func_run_time_cache(&fbc->op_array);
38841 }
38842 }
38843
38844 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
38845 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
38846 ce = (zend_class_entry*)Z_OBJ(EX(This));
38847 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
38848 } else {
38849 zend_non_static_method_call(fbc);
38850 HANDLE_EXCEPTION();
38851 }
38852 } else {
38853 /* previous opcode is ZEND_FETCH_CLASS */
38854 if (IS_UNUSED == IS_UNUSED
38855 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
38856 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
38857 if (Z_TYPE(EX(This)) == IS_OBJECT) {
38858 ce = Z_OBJCE(EX(This));
38859 } else {
38860 ce = Z_CE(EX(This));
38861 }
38862 }
38863 call_info = ZEND_CALL_NESTED_FUNCTION;
38864 }
38865
38866 call = zend_vm_stack_push_call_frame(call_info,
38867 fbc, opline->extended_value, ce);
38868 call->prev_execute_data = EX(call);
38869 EX(call) = call;
38870
38871 ZEND_VM_NEXT_OPCODE();
38872 }
38873
ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38874 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38875 {
38876 zval *array;
38877 uint32_t size;
38878 USE_OPLINE
38879
38880 array = EX_VAR(opline->result.var);
38881 if (IS_UNUSED != IS_UNUSED) {
38882 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
38883 ZVAL_ARR(array, zend_new_array(size));
38884 /* Explicitly initialize array as not-packed if flag is set */
38885 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
38886 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
38887 }
38888 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38889 } else {
38890 ZVAL_ARR(array, zend_new_array(0));
38891 ZEND_VM_NEXT_OPCODE();
38892 }
38893 }
38894
ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38895 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38896 {
38897 USE_OPLINE
38898 zval *container;
38899 zval *offset;
38900 zend_string *name, *tmp_name;
38901
38902 SAVE_OPLINE();
38903 container = &EX(This);
38904 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38905
38906 do {
38907 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
38908 if (Z_ISREF_P(container)) {
38909 container = Z_REFVAL_P(container);
38910 if (Z_TYPE_P(container) != IS_OBJECT) {
38911 if (IS_UNUSED == IS_CV
38912 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
38913 ZVAL_UNDEFINED_OP1();
38914 }
38915 break;
38916 }
38917 } else {
38918 break;
38919 }
38920 }
38921 if (IS_CV == IS_CONST) {
38922 name = Z_STR_P(offset);
38923 } else {
38924 name = zval_try_get_tmp_string(offset, &tmp_name);
38925 if (UNEXPECTED(!name)) {
38926 break;
38927 }
38928 }
38929 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
38930 if (IS_CV != IS_CONST) {
38931 zend_tmp_string_release(tmp_name);
38932 }
38933 } while (0);
38934
38935
38936 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38937 }
38938
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38939 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38940 {
38941 USE_OPLINE
38942 zval *container;
38943 int result;
38944 zval *offset;
38945 zend_string *name, *tmp_name;
38946
38947 SAVE_OPLINE();
38948 container = &EX(This);
38949 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38950
38951 if (IS_UNUSED == IS_CONST ||
38952 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
38953 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
38954 container = Z_REFVAL_P(container);
38955 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
38956 result = (opline->extended_value & ZEND_ISEMPTY);
38957 goto isset_object_finish;
38958 }
38959 } else {
38960 result = (opline->extended_value & ZEND_ISEMPTY);
38961 goto isset_object_finish;
38962 }
38963 }
38964
38965 if (IS_CV == IS_CONST) {
38966 name = Z_STR_P(offset);
38967 } else {
38968 name = zval_try_get_tmp_string(offset, &tmp_name);
38969 if (UNEXPECTED(!name)) {
38970 result = 0;
38971 goto isset_object_finish;
38972 }
38973 }
38974
38975 result =
38976 (opline->extended_value & ZEND_ISEMPTY) ^
38977 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));
38978
38979 if (IS_CV != IS_CONST) {
38980 zend_tmp_string_release(tmp_name);
38981 }
38982
38983 isset_object_finish:
38984
38985
38986 ZEND_VM_SMART_BRANCH(result, 1);
38987 }
38988
ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38989 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38990 {
38991 USE_OPLINE
38992
38993 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
38994
38995 SAVE_OPLINE();
38996 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
38997 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38998 }
38999
39000 /* Destroy the previously yielded value */
39001 zval_ptr_dtor(&generator->value);
39002
39003 /* Destroy the previously yielded key */
39004 zval_ptr_dtor(&generator->key);
39005
39006 /* Set the new yielded value */
39007 if (IS_UNUSED != IS_UNUSED) {
39008 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
39009 /* Constants and temporary variables aren't yieldable by reference,
39010 * but we still allow them with a notice. */
39011 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
39012 zval *value;
39013
39014 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
39015
39016 value = NULL;
39017 ZVAL_COPY_VALUE(&generator->value, value);
39018 if (IS_UNUSED == IS_CONST) {
39019 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
39020 Z_ADDREF(generator->value);
39021 }
39022 }
39023 } else {
39024 zval *value_ptr = NULL;
39025
39026 /* If a function call result is yielded and the function did
39027 * not return by reference we throw a notice. */
39028 do {
39029 if (IS_UNUSED == IS_VAR) {
39030 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
39031 if (opline->extended_value == ZEND_RETURNS_FUNCTION
39032 && !Z_ISREF_P(value_ptr)) {
39033 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
39034 ZVAL_COPY(&generator->value, value_ptr);
39035 break;
39036 }
39037 }
39038 if (Z_ISREF_P(value_ptr)) {
39039 Z_ADDREF_P(value_ptr);
39040 } else {
39041 ZVAL_MAKE_REF_EX(value_ptr, 2);
39042 }
39043 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
39044 } while (0);
39045
39046 }
39047 } else {
39048 zval *value = NULL;
39049
39050 /* Consts, temporary variables and references need copying */
39051 if (IS_UNUSED == IS_CONST) {
39052 ZVAL_COPY_VALUE(&generator->value, value);
39053 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
39054 Z_ADDREF(generator->value);
39055 }
39056 } else if (IS_UNUSED == IS_TMP_VAR) {
39057 ZVAL_COPY_VALUE(&generator->value, value);
39058 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
39059 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
39060
39061 } else {
39062 ZVAL_COPY_VALUE(&generator->value, value);
39063 if (IS_UNUSED == IS_CV) {
39064 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
39065 }
39066 }
39067 }
39068 } else {
39069 /* If no value was specified yield null */
39070 ZVAL_NULL(&generator->value);
39071 }
39072
39073 /* Set the new yielded key */
39074 if (IS_CV != IS_UNUSED) {
39075 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39076 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
39077 key = Z_REFVAL_P(key);
39078 }
39079 ZVAL_COPY(&generator->key, key);
39080
39081 if (Z_TYPE(generator->key) == IS_LONG
39082 && Z_LVAL(generator->key) > generator->largest_used_integer_key
39083 ) {
39084 generator->largest_used_integer_key = Z_LVAL(generator->key);
39085 }
39086 } else {
39087 /* If no key was specified we use auto-increment keys */
39088 generator->largest_used_integer_key++;
39089 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
39090 }
39091
39092 if (RETURN_VALUE_USED(opline)) {
39093 /* If the return value of yield is used set the send
39094 * target and initialize it to NULL */
39095 generator->send_target = EX_VAR(opline->result.var);
39096 ZVAL_NULL(generator->send_target);
39097 } else {
39098 generator->send_target = NULL;
39099 }
39100
39101 /* We increment to the next op, so we are at the correct position when the
39102 * generator is resumed. */
39103 ZEND_VM_INC_OPCODE();
39104
39105 /* The GOTO VM uses a local opline variable. We need to set the opline
39106 * variable in execute_data so we don't resume at an old position. */
39107 SAVE_OPLINE();
39108
39109 ZEND_VM_RETURN();
39110 }
39111
ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39112 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39113 {
39114 USE_OPLINE
39115 zval *val;
39116
39117 val = EX_VAR(opline->op1.var);
39118 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39119 ZVAL_FALSE(EX_VAR(opline->result.var));
39120 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39121 /* The result and op1 can be the same cv zval */
39122 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
39123 ZVAL_TRUE(EX_VAR(opline->result.var));
39124 if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
39125 SAVE_OPLINE();
39126 ZVAL_UNDEFINED_OP1();
39127 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39128 }
39129 } else {
39130 SAVE_OPLINE();
39131 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
39132
39133 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39134 }
39135 ZEND_VM_NEXT_OPCODE();
39136 }
39137
zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)39138 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
39139 {
39140 USE_OPLINE
39141 zval *var_ptr;
39142
39143 var_ptr = EX_VAR(opline->op1.var);
39144
39145 SAVE_OPLINE();
39146 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
39147 ZVAL_UNDEFINED_OP1();
39148 ZVAL_NULL(var_ptr);
39149 }
39150
39151 do {
39152 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
39153 zend_reference *ref = Z_REF_P(var_ptr);
39154 var_ptr = Z_REFVAL_P(var_ptr);
39155 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
39156 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
39157 break;
39158 }
39159 }
39160 increment_function(var_ptr);
39161 } while (0);
39162
39163 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39164 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
39165 }
39166
39167 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39168 }
39169
ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39170 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_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(0)) {
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_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39188 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39189 {
39190 USE_OPLINE
39191 zval *var_ptr;
39192
39193 var_ptr = EX_VAR(opline->op1.var);
39194
39195 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
39196 fast_long_increment_function(var_ptr);
39197 if (UNEXPECTED(1)) {
39198 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
39199 }
39200 ZEND_VM_NEXT_OPCODE();
39201 }
39202
39203 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39204 }
39205
zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)39206 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
39207 {
39208 USE_OPLINE
39209 zval *var_ptr;
39210
39211 var_ptr = EX_VAR(opline->op1.var);
39212
39213 SAVE_OPLINE();
39214 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
39215 ZVAL_UNDEFINED_OP1();
39216 ZVAL_NULL(var_ptr);
39217 }
39218
39219 do {
39220 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
39221 zend_reference *ref = Z_REF_P(var_ptr);
39222 var_ptr = Z_REFVAL_P(var_ptr);
39223
39224 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
39225 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
39226 break;
39227 }
39228 }
39229 decrement_function(var_ptr);
39230 } while (0);
39231
39232 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39233 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
39234 }
39235
39236 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39237 }
39238
ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39239 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_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(0)) {
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_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39257 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39258 {
39259 USE_OPLINE
39260 zval *var_ptr;
39261
39262 var_ptr = EX_VAR(opline->op1.var);
39263
39264 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
39265 fast_long_decrement_function(var_ptr);
39266 if (UNEXPECTED(1)) {
39267 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
39268 }
39269 ZEND_VM_NEXT_OPCODE();
39270 }
39271
39272 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39273 }
39274
zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)39275 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
39276 {
39277 USE_OPLINE
39278 zval *var_ptr;
39279
39280 var_ptr = EX_VAR(opline->op1.var);
39281
39282 SAVE_OPLINE();
39283 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
39284 ZVAL_UNDEFINED_OP1();
39285 ZVAL_NULL(var_ptr);
39286 }
39287
39288 do {
39289 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
39290 zend_reference *ref = Z_REF_P(var_ptr);
39291 var_ptr = Z_REFVAL_P(var_ptr);
39292
39293 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
39294 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
39295 break;
39296 }
39297 }
39298 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
39299
39300 increment_function(var_ptr);
39301 } while (0);
39302
39303 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39304 }
39305
ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39306 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39307 {
39308 USE_OPLINE
39309 zval *var_ptr;
39310
39311 var_ptr = EX_VAR(opline->op1.var);
39312
39313 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
39314 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
39315 fast_long_increment_function(var_ptr);
39316 ZEND_VM_NEXT_OPCODE();
39317 }
39318
39319 ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39320 }
39321
zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)39322 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
39323 {
39324 USE_OPLINE
39325 zval *var_ptr;
39326
39327 var_ptr = EX_VAR(opline->op1.var);
39328
39329 SAVE_OPLINE();
39330 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
39331 ZVAL_UNDEFINED_OP1();
39332 ZVAL_NULL(var_ptr);
39333 }
39334
39335 do {
39336 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
39337 zend_reference *ref = Z_REF_P(var_ptr);
39338 var_ptr = Z_REFVAL_P(var_ptr);
39339
39340 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
39341 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
39342 break;
39343 }
39344 }
39345 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
39346
39347 decrement_function(var_ptr);
39348 } while (0);
39349
39350 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39351 }
39352
ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39353 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39354 {
39355 USE_OPLINE
39356 zval *var_ptr;
39357
39358 var_ptr = EX_VAR(opline->op1.var);
39359
39360 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
39361 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
39362 fast_long_decrement_function(var_ptr);
39363 ZEND_VM_NEXT_OPCODE();
39364 }
39365
39366 ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39367 }
39368
ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39369 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39370 {
39371 USE_OPLINE
39372 zval *z;
39373
39374 SAVE_OPLINE();
39375 z = EX_VAR(opline->op1.var);
39376
39377 if (Z_TYPE_P(z) == IS_STRING) {
39378 zend_string *str = Z_STR_P(z);
39379
39380 if (ZSTR_LEN(str) != 0) {
39381 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
39382 }
39383 } else {
39384 zend_string *str = zval_get_string_func(z);
39385
39386 if (ZSTR_LEN(str) != 0) {
39387 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
39388 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
39389 ZVAL_UNDEFINED_OP1();
39390 }
39391 zend_string_release_ex(str, 0);
39392 }
39393
39394 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39395 }
39396
ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39397 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39398 {
39399 USE_OPLINE
39400 zval *val;
39401 uint8_t op1_type;
39402
39403 val = EX_VAR(opline->op1.var);
39404
39405 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39406 ZEND_VM_NEXT_OPCODE();
39407 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39408 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
39409 SAVE_OPLINE();
39410 ZVAL_UNDEFINED_OP1();
39411 if (UNEXPECTED(EG(exception))) {
39412 HANDLE_EXCEPTION();
39413 }
39414 }
39415 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
39416 }
39417
39418 SAVE_OPLINE();
39419 op1_type = IS_CV;
39420 if (i_zend_is_true(val)) {
39421 opline++;
39422 } else {
39423 opline = OP_JMP_ADDR(opline, opline->op2);
39424 }
39425 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
39426 zval_ptr_dtor_nogc(val);
39427 }
39428 ZEND_VM_JMP(opline);
39429 }
39430
ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39431 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39432 {
39433 USE_OPLINE
39434 zval *val;
39435 uint8_t op1_type;
39436
39437 val = EX_VAR(opline->op1.var);
39438
39439 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39440 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
39441 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39442 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
39443 SAVE_OPLINE();
39444 ZVAL_UNDEFINED_OP1();
39445 if (UNEXPECTED(EG(exception))) {
39446 HANDLE_EXCEPTION();
39447 }
39448 }
39449 ZEND_VM_NEXT_OPCODE();
39450 }
39451
39452 SAVE_OPLINE();
39453 op1_type = IS_CV;
39454 if (i_zend_is_true(val)) {
39455 opline = OP_JMP_ADDR(opline, opline->op2);
39456 } else {
39457 opline++;
39458 }
39459 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
39460 zval_ptr_dtor_nogc(val);
39461 }
39462 ZEND_VM_JMP(opline);
39463 }
39464
ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39465 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39466 {
39467 USE_OPLINE
39468 zval *val;
39469 bool ret;
39470
39471 val = EX_VAR(opline->op1.var);
39472
39473 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39474 ZVAL_TRUE(EX_VAR(opline->result.var));
39475 ZEND_VM_NEXT_OPCODE();
39476 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39477 ZVAL_FALSE(EX_VAR(opline->result.var));
39478 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
39479 SAVE_OPLINE();
39480 ZVAL_UNDEFINED_OP1();
39481 if (UNEXPECTED(EG(exception))) {
39482 HANDLE_EXCEPTION();
39483 }
39484 }
39485 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
39486 }
39487
39488 SAVE_OPLINE();
39489 ret = i_zend_is_true(val);
39490
39491 if (ret) {
39492 ZVAL_TRUE(EX_VAR(opline->result.var));
39493 opline++;
39494 } else {
39495 ZVAL_FALSE(EX_VAR(opline->result.var));
39496 opline = OP_JMP_ADDR(opline, opline->op2);
39497 }
39498 ZEND_VM_JMP(opline);
39499 }
39500
ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39501 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39502 {
39503 USE_OPLINE
39504 zval *val;
39505 bool ret;
39506
39507 val = EX_VAR(opline->op1.var);
39508
39509 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39510 ZVAL_TRUE(EX_VAR(opline->result.var));
39511 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
39512 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39513 ZVAL_FALSE(EX_VAR(opline->result.var));
39514 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
39515 SAVE_OPLINE();
39516 ZVAL_UNDEFINED_OP1();
39517 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39518 } else {
39519 ZEND_VM_NEXT_OPCODE();
39520 }
39521 }
39522
39523 SAVE_OPLINE();
39524 ret = i_zend_is_true(val);
39525
39526 if (ret) {
39527 ZVAL_TRUE(EX_VAR(opline->result.var));
39528 opline = OP_JMP_ADDR(opline, opline->op2);
39529 } else {
39530 ZVAL_FALSE(EX_VAR(opline->result.var));
39531 opline++;
39532 }
39533 ZEND_VM_JMP(opline);
39534 }
39535
ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39536 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39537 {
39538 USE_OPLINE
39539 zval *retval_ptr;
39540 zval *return_value;
39541
39542 retval_ptr = EX_VAR(opline->op1.var);
39543 return_value = EX(return_value);
39544
39545 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
39546 SAVE_OPLINE();
39547 retval_ptr = ZVAL_UNDEFINED_OP1();
39548 if (return_value) {
39549 ZVAL_NULL(return_value);
39550 }
39551 } else if (!return_value) {
39552 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
39553 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
39554 SAVE_OPLINE();
39555 rc_dtor_func(Z_COUNTED_P(retval_ptr));
39556 }
39557 }
39558 } else {
39559 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
39560 ZVAL_COPY_VALUE(return_value, retval_ptr);
39561 if (IS_CV == IS_CONST) {
39562 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
39563 Z_ADDREF_P(return_value);
39564 }
39565 }
39566 } else if (IS_CV == IS_CV) {
39567 do {
39568 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
39569 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
39570 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
39571 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
39572 ZVAL_COPY_VALUE(return_value, retval_ptr);
39573 if (GC_MAY_LEAK(ref)) {
39574 SAVE_OPLINE();
39575 gc_possible_root(ref);
39576 }
39577 ZVAL_NULL(retval_ptr);
39578 break;
39579 } else {
39580 Z_ADDREF_P(retval_ptr);
39581 }
39582 } else {
39583 retval_ptr = Z_REFVAL_P(retval_ptr);
39584 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
39585 Z_ADDREF_P(retval_ptr);
39586 }
39587 }
39588 }
39589 ZVAL_COPY_VALUE(return_value, retval_ptr);
39590 } while (0);
39591 } else /* if (IS_CV == IS_VAR) */ {
39592 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
39593 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
39594
39595 retval_ptr = Z_REFVAL_P(retval_ptr);
39596 ZVAL_COPY_VALUE(return_value, retval_ptr);
39597 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
39598 efree_size(ref, sizeof(zend_reference));
39599 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
39600 Z_ADDREF_P(retval_ptr);
39601 }
39602 } else {
39603 ZVAL_COPY_VALUE(return_value, retval_ptr);
39604 }
39605 }
39606 }
39607
39608
39609
39610 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39611 }
39612
ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39613 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39614 {
39615 USE_OPLINE
39616 zval *retval_ptr;
39617 zval *return_value;
39618
39619 SAVE_OPLINE();
39620
39621 return_value = EX(return_value);
39622
39623 do {
39624 if ((IS_CV & (IS_CONST|IS_TMP_VAR)) ||
39625 (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
39626 /* Not supposed to happen, but we'll allow it */
39627 zend_error(E_NOTICE, "Only variable references should be returned by reference");
39628
39629 retval_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
39630 if (!return_value) {
39631
39632 } else {
39633 if (IS_CV == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
39634 ZVAL_COPY_VALUE(return_value, retval_ptr);
39635 break;
39636 }
39637
39638 ZVAL_NEW_REF(return_value, retval_ptr);
39639 if (IS_CV == IS_CONST) {
39640 Z_TRY_ADDREF_P(retval_ptr);
39641 }
39642 }
39643 break;
39644 }
39645
39646 retval_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
39647
39648 if (IS_CV == IS_VAR) {
39649 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
39650 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
39651 zend_error(E_NOTICE, "Only variable references should be returned by reference");
39652 if (return_value) {
39653 ZVAL_NEW_REF(return_value, retval_ptr);
39654 } else {
39655
39656 }
39657 break;
39658 }
39659 }
39660
39661 if (return_value) {
39662 if (Z_ISREF_P(retval_ptr)) {
39663 Z_ADDREF_P(retval_ptr);
39664 } else {
39665 ZVAL_MAKE_REF_EX(retval_ptr, 2);
39666 }
39667 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
39668 }
39669
39670 } while (0);
39671
39672
39673 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39674 }
39675
ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39676 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39677 {
39678 USE_OPLINE
39679 zval *retval;
39680
39681 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
39682
39683 SAVE_OPLINE();
39684 retval = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
39685
39686 /* Copy return value into generator->retval */
39687 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
39688 ZVAL_COPY_VALUE(&generator->retval, retval);
39689 if (IS_CV == IS_CONST) {
39690 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
39691 Z_ADDREF(generator->retval);
39692 }
39693 }
39694 } else if (IS_CV == IS_CV) {
39695 ZVAL_COPY_DEREF(&generator->retval, retval);
39696 } else /* if (IS_CV == IS_VAR) */ {
39697 if (UNEXPECTED(Z_ISREF_P(retval))) {
39698 zend_refcounted *ref = Z_COUNTED_P(retval);
39699
39700 retval = Z_REFVAL_P(retval);
39701 ZVAL_COPY_VALUE(&generator->retval, retval);
39702 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
39703 efree_size(ref, sizeof(zend_reference));
39704 } else if (Z_OPT_REFCOUNTED_P(retval)) {
39705 Z_ADDREF_P(retval);
39706 }
39707 } else {
39708 ZVAL_COPY_VALUE(&generator->retval, retval);
39709 }
39710 }
39711
39712 EG(current_execute_data) = EX(prev_execute_data);
39713
39714 /* Close the generator to free up resources */
39715 zend_generator_close(generator, 1);
39716
39717 /* Pass execution back to handling code */
39718 ZEND_VM_RETURN();
39719 }
39720
ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39721 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39722 {
39723 USE_OPLINE
39724 zval *value;
39725
39726 SAVE_OPLINE();
39727 value = EX_VAR(opline->op1.var);
39728
39729 do {
39730 if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
39731 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
39732 value = Z_REFVAL_P(value);
39733 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
39734 break;
39735 }
39736 }
39737 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
39738 ZVAL_UNDEFINED_OP1();
39739 if (UNEXPECTED(EG(exception) != NULL)) {
39740 HANDLE_EXCEPTION();
39741 }
39742 }
39743 zend_throw_error(NULL, "Can only throw objects");
39744
39745 HANDLE_EXCEPTION();
39746 }
39747 } while (0);
39748
39749 zend_exception_save();
39750 Z_TRY_ADDREF_P(value);
39751 zend_throw_exception_object(value);
39752 zend_exception_restore();
39753
39754 HANDLE_EXCEPTION();
39755 }
39756
ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39757 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39758 {
39759 USE_OPLINE
39760 zval *arg, *param;
39761
39762 SAVE_OPLINE();
39763
39764 arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
39765 param = ZEND_CALL_VAR(EX(call), opline->result.var);
39766 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
39767 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
39768 Z_TRY_ADDREF_P(arg);
39769 ZVAL_NEW_REF(param, arg);
39770 } else {
39771 ZVAL_COPY(param, arg);
39772 }
39773
39774 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39775 }
39776
ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39777 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39778 {
39779 USE_OPLINE
39780 zval *val;
39781
39782 val = EX_VAR(opline->op1.var);
39783 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39784 ZVAL_TRUE(EX_VAR(opline->result.var));
39785 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39786 /* The result and op1 can be the same cv zval */
39787 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
39788 ZVAL_FALSE(EX_VAR(opline->result.var));
39789 if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
39790 SAVE_OPLINE();
39791 ZVAL_UNDEFINED_OP1();
39792 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39793 }
39794 } else {
39795 SAVE_OPLINE();
39796 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
39797
39798 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39799 }
39800 ZEND_VM_NEXT_OPCODE();
39801 }
39802
ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39803 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39804 {
39805 USE_OPLINE
39806 zval *obj;
39807 zend_object *zobj;
39808 zend_class_entry *ce, *scope;
39809 zend_function *clone;
39810 zend_object_clone_obj_t clone_call;
39811
39812 SAVE_OPLINE();
39813 obj = EX_VAR(opline->op1.var);
39814
39815 do {
39816 if (IS_CV == IS_CONST ||
39817 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
39818 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
39819 obj = Z_REFVAL_P(obj);
39820 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
39821 break;
39822 }
39823 }
39824 ZVAL_UNDEF(EX_VAR(opline->result.var));
39825 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
39826 ZVAL_UNDEFINED_OP1();
39827 if (UNEXPECTED(EG(exception) != NULL)) {
39828 HANDLE_EXCEPTION();
39829 }
39830 }
39831 zend_throw_error(NULL, "__clone method called on non-object");
39832
39833 HANDLE_EXCEPTION();
39834 }
39835 } while (0);
39836
39837 zobj = Z_OBJ_P(obj);
39838 ce = zobj->ce;
39839 clone = ce->clone;
39840 clone_call = zobj->handlers->clone_obj;
39841 if (UNEXPECTED(clone_call == NULL)) {
39842 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
39843
39844 ZVAL_UNDEF(EX_VAR(opline->result.var));
39845 HANDLE_EXCEPTION();
39846 }
39847
39848 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
39849 scope = EX(func)->op_array.scope;
39850 if (clone->common.scope != scope) {
39851 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
39852 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
39853 zend_wrong_clone_call(clone, scope);
39854
39855 ZVAL_UNDEF(EX_VAR(opline->result.var));
39856 HANDLE_EXCEPTION();
39857 }
39858 }
39859 }
39860
39861 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
39862
39863 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39864 }
39865
ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39866 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39867 {
39868 USE_OPLINE
39869 zval *expr;
39870 zval *result = EX_VAR(opline->result.var);
39871 HashTable *ht;
39872
39873 SAVE_OPLINE();
39874 expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
39875
39876 switch (opline->extended_value) {
39877 case IS_LONG:
39878 ZVAL_LONG(result, zval_get_long(expr));
39879 break;
39880 case IS_DOUBLE:
39881 ZVAL_DOUBLE(result, zval_get_double(expr));
39882 break;
39883 case IS_STRING:
39884 ZVAL_STR(result, zval_get_string(expr));
39885 break;
39886 default:
39887 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
39888 if (IS_CV & (IS_VAR|IS_CV)) {
39889 ZVAL_DEREF(expr);
39890 }
39891 /* If value is already of correct type, return it directly */
39892 if (Z_TYPE_P(expr) == opline->extended_value) {
39893 ZVAL_COPY_VALUE(result, expr);
39894 if (IS_CV == IS_CONST) {
39895 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
39896 } else if (IS_CV != IS_TMP_VAR) {
39897 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
39898 }
39899
39900 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39901 }
39902
39903 if (opline->extended_value == IS_ARRAY) {
39904 if (IS_CV == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
39905 if (Z_TYPE_P(expr) != IS_NULL) {
39906 ZVAL_ARR(result, zend_new_array(1));
39907 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
39908 if (IS_CV == IS_CONST) {
39909 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
39910 } else {
39911 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
39912 }
39913 } else {
39914 ZVAL_EMPTY_ARRAY(result);
39915 }
39916 } else if (Z_OBJ_P(expr)->properties == NULL
39917 && Z_OBJ_HT_P(expr)->get_properties_for == NULL
39918 && Z_OBJ_HT_P(expr)->get_properties == zend_std_get_properties) {
39919 /* Optimized version without rebuilding properties HashTable */
39920 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
39921 } else {
39922 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
39923 if (obj_ht) {
39924 /* fast copy */
39925 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
39926 (Z_OBJCE_P(expr)->default_properties_count ||
39927 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
39928 GC_IS_RECURSIVE(obj_ht))));
39929 zend_release_properties(obj_ht);
39930 } else {
39931 ZVAL_EMPTY_ARRAY(result);
39932 }
39933 }
39934 } else {
39935 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
39936 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
39937 if (Z_TYPE_P(expr) == IS_ARRAY) {
39938 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
39939 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
39940 /* TODO: try not to duplicate immutable arrays as well ??? */
39941 ht = zend_array_dup(ht);
39942 }
39943 Z_OBJ_P(result)->properties = ht;
39944 } else if (Z_TYPE_P(expr) != IS_NULL) {
39945 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
39946 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
39947 if (IS_CV == IS_CONST) {
39948 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
39949 } else {
39950 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
39951 }
39952 }
39953 }
39954 }
39955
39956 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39957 }
39958
ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39959 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39960 {
39961 USE_OPLINE
39962 zend_op_array *new_op_array;
39963 zval *inc_filename;
39964
39965 SAVE_OPLINE();
39966 inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
39967 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
39968 if (UNEXPECTED(EG(exception) != NULL)) {
39969
39970 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
39971 destroy_op_array(new_op_array);
39972 efree_size(new_op_array, sizeof(zend_op_array));
39973 }
39974 UNDEF_RESULT();
39975 HANDLE_EXCEPTION();
39976 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
39977 if (RETURN_VALUE_USED(opline)) {
39978 ZVAL_TRUE(EX_VAR(opline->result.var));
39979 }
39980 } else if (UNEXPECTED(new_op_array == NULL)) {
39981 if (RETURN_VALUE_USED(opline)) {
39982 ZVAL_FALSE(EX_VAR(opline->result.var));
39983 }
39984 } else if (new_op_array->last == 1
39985 && new_op_array->opcodes[0].opcode == ZEND_RETURN
39986 && new_op_array->opcodes[0].op1_type == IS_CONST
39987 && EXPECTED(zend_execute_ex == execute_ex)) {
39988 if (RETURN_VALUE_USED(opline)) {
39989 const zend_op *op = new_op_array->opcodes;
39990
39991 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
39992 }
39993 zend_destroy_static_vars(new_op_array);
39994 destroy_op_array(new_op_array);
39995 efree_size(new_op_array, sizeof(zend_op_array));
39996 } else {
39997 zval *return_value = NULL;
39998 zend_execute_data *call;
39999 if (RETURN_VALUE_USED(opline)) {
40000 return_value = EX_VAR(opline->result.var);
40001 }
40002
40003 new_op_array->scope = EX(func)->op_array.scope;
40004
40005 call = zend_vm_stack_push_call_frame(
40006 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
40007 (zend_function*)new_op_array, 0,
40008 Z_PTR(EX(This)));
40009
40010 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
40011 call->symbol_table = EX(symbol_table);
40012 } else {
40013 call->symbol_table = zend_rebuild_symbol_table();
40014 }
40015
40016 call->prev_execute_data = execute_data;
40017 i_init_code_execute_data(call, new_op_array, return_value);
40018
40019 if (EXPECTED(zend_execute_ex == execute_ex)) {
40020
40021 ZEND_VM_ENTER();
40022 } else {
40023 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
40024 zend_execute_ex(call);
40025 zend_vm_stack_free_call_frame(call);
40026 }
40027
40028 zend_destroy_static_vars(new_op_array);
40029 destroy_op_array(new_op_array);
40030 efree_size(new_op_array, sizeof(zend_op_array));
40031 if (UNEXPECTED(EG(exception) != NULL)) {
40032 zend_rethrow_exception(execute_data);
40033
40034 UNDEF_RESULT();
40035 HANDLE_EXCEPTION();
40036 }
40037 }
40038
40039 ZEND_VM_NEXT_OPCODE();
40040 }
40041
ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40042 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40043 {
40044 USE_OPLINE
40045 zval *array_ptr, *result;
40046
40047 SAVE_OPLINE();
40048
40049 array_ptr = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40050 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
40051 result = EX_VAR(opline->result.var);
40052 ZVAL_COPY_VALUE(result, array_ptr);
40053 if (IS_CV != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
40054 Z_ADDREF_P(array_ptr);
40055 }
40056 Z_FE_POS_P(result) = 0;
40057
40058 ZEND_VM_NEXT_OPCODE();
40059 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
40060 zend_object *zobj = Z_OBJ_P(array_ptr);
40061 if (!zobj->ce->get_iterator) {
40062 HashTable *properties = zobj->properties;
40063 if (properties) {
40064 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
40065 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
40066 GC_DELREF(properties);
40067 }
40068 properties = zobj->properties = zend_array_dup(properties);
40069 }
40070 } else {
40071 properties = zobj->handlers->get_properties(zobj);
40072 }
40073
40074 result = EX_VAR(opline->result.var);
40075 ZVAL_COPY_VALUE(result, array_ptr);
40076 if (IS_CV != IS_TMP_VAR) {
40077 Z_ADDREF_P(array_ptr);
40078 }
40079
40080 if (zend_hash_num_elements(properties) == 0) {
40081 Z_FE_ITER_P(result) = (uint32_t) -1;
40082
40083 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
40084 }
40085
40086 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
40087
40088 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40089 } else {
40090 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
40091
40092 if (UNEXPECTED(EG(exception))) {
40093 HANDLE_EXCEPTION();
40094 } else if (is_empty) {
40095 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40096 } else {
40097 ZEND_VM_NEXT_OPCODE();
40098 }
40099 }
40100 } else {
40101 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
40102 ZVAL_UNDEF(EX_VAR(opline->result.var));
40103 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
40104
40105 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
40106 }
40107 }
40108
ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40109 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40110 {
40111 USE_OPLINE
40112 zval *array_ptr, *array_ref;
40113
40114 SAVE_OPLINE();
40115
40116 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
40117 array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40118 if (Z_ISREF_P(array_ref)) {
40119 array_ptr = Z_REFVAL_P(array_ref);
40120 }
40121 } else {
40122 array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40123 }
40124
40125 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
40126 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
40127 if (array_ptr == array_ref) {
40128 ZVAL_NEW_REF(array_ref, array_ref);
40129 array_ptr = Z_REFVAL_P(array_ref);
40130 }
40131 Z_ADDREF_P(array_ref);
40132 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
40133 } else {
40134 array_ref = EX_VAR(opline->result.var);
40135 ZVAL_NEW_REF(array_ref, array_ptr);
40136 array_ptr = Z_REFVAL_P(array_ref);
40137 }
40138 if (IS_CV == IS_CONST) {
40139 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
40140 } else {
40141 SEPARATE_ARRAY(array_ptr);
40142 }
40143 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
40144
40145 ZEND_VM_NEXT_OPCODE();
40146 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
40147 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
40148 HashTable *properties;
40149 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
40150 if (array_ptr == array_ref) {
40151 ZVAL_NEW_REF(array_ref, array_ref);
40152 array_ptr = Z_REFVAL_P(array_ref);
40153 }
40154 Z_ADDREF_P(array_ref);
40155 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
40156 } else {
40157 array_ptr = EX_VAR(opline->result.var);
40158 ZVAL_COPY_VALUE(array_ptr, array_ref);
40159 }
40160 if (Z_OBJ_P(array_ptr)->properties
40161 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
40162 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
40163 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
40164 }
40165 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
40166 }
40167
40168 properties = Z_OBJPROP_P(array_ptr);
40169 if (zend_hash_num_elements(properties) == 0) {
40170 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
40171
40172 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
40173 }
40174
40175 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
40176
40177 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40178 } else {
40179 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
40180
40181 if (UNEXPECTED(EG(exception))) {
40182 HANDLE_EXCEPTION();
40183 } else if (is_empty) {
40184 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40185 } else {
40186 ZEND_VM_NEXT_OPCODE();
40187 }
40188 }
40189 } else {
40190 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
40191 ZVAL_UNDEF(EX_VAR(opline->result.var));
40192 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
40193
40194 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
40195 }
40196 }
40197
ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40198 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40199 {
40200 USE_OPLINE
40201 zval *value;
40202 zend_reference *ref = NULL;
40203 bool ret;
40204
40205 SAVE_OPLINE();
40206 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40207
40208 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(value)) {
40209 if (IS_CV == IS_VAR) {
40210 ref = Z_REF_P(value);
40211 }
40212 value = Z_REFVAL_P(value);
40213 }
40214
40215 ret = i_zend_is_true(value);
40216
40217 if (UNEXPECTED(EG(exception))) {
40218
40219 ZVAL_UNDEF(EX_VAR(opline->result.var));
40220 HANDLE_EXCEPTION();
40221 }
40222
40223 if (ret) {
40224 zval *result = EX_VAR(opline->result.var);
40225
40226 ZVAL_COPY_VALUE(result, value);
40227 if (IS_CV == IS_CONST) {
40228 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
40229 } else if (IS_CV == IS_CV) {
40230 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
40231 } else if (IS_CV == IS_VAR && ref) {
40232 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40233 efree_size(ref, sizeof(zend_reference));
40234 } else if (Z_OPT_REFCOUNTED_P(result)) {
40235 Z_ADDREF_P(result);
40236 }
40237 }
40238 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40239 }
40240
40241 ZEND_VM_NEXT_OPCODE();
40242 }
40243
ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40244 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40245 {
40246 USE_OPLINE
40247 zval *value;
40248 zend_reference *ref = NULL;
40249
40250 SAVE_OPLINE();
40251 value = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
40252
40253 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
40254 if (IS_CV & IS_VAR) {
40255 ref = Z_REF_P(value);
40256 }
40257 value = Z_REFVAL_P(value);
40258 }
40259
40260 if (Z_TYPE_P(value) > IS_NULL) {
40261 zval *result = EX_VAR(opline->result.var);
40262 ZVAL_COPY_VALUE(result, value);
40263 if (IS_CV == IS_CONST) {
40264 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
40265 } else if (IS_CV == IS_CV) {
40266 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
40267 } else if ((IS_CV & IS_VAR) && ref) {
40268 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40269 efree_size(ref, sizeof(zend_reference));
40270 } else if (Z_OPT_REFCOUNTED_P(result)) {
40271 Z_ADDREF_P(result);
40272 }
40273 }
40274 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40275 }
40276
40277 if ((IS_CV & IS_VAR) && ref) {
40278 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40279 efree_size(ref, sizeof(zend_reference));
40280 }
40281 }
40282 ZEND_VM_NEXT_OPCODE();
40283 }
40284
ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40285 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40286 {
40287 USE_OPLINE
40288 zval *val, *result;
40289
40290 val = EX_VAR(opline->op1.var);
40291
40292 if (Z_TYPE_P(val) > IS_NULL) {
40293 do {
40294 if ((IS_CV == IS_CV || IS_CV == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
40295 val = Z_REFVAL_P(val);
40296 if (Z_TYPE_P(val) <= IS_NULL) {
40297
40298 break;
40299 }
40300 }
40301 ZEND_VM_NEXT_OPCODE();
40302 } while (0);
40303 }
40304
40305 result = EX_VAR(opline->result.var);
40306 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
40307 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
40308 ZVAL_NULL(result);
40309 if (IS_CV == IS_CV
40310 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
40311 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
40312 ) {
40313 SAVE_OPLINE();
40314 ZVAL_UNDEFINED_OP1();
40315 if (UNEXPECTED(EG(exception) != NULL)) {
40316 HANDLE_EXCEPTION();
40317 }
40318 }
40319 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
40320 ZVAL_FALSE(result);
40321 } else {
40322 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
40323 ZVAL_TRUE(result);
40324 }
40325
40326 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40327 }
40328
ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40329 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40330 {
40331 USE_OPLINE
40332 zval *value;
40333 zval *result = EX_VAR(opline->result.var);
40334
40335 value = EX_VAR(opline->op1.var);
40336 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
40337 SAVE_OPLINE();
40338 ZVAL_UNDEFINED_OP1();
40339 ZVAL_NULL(result);
40340 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40341 }
40342
40343 if (IS_CV == IS_CV) {
40344 ZVAL_COPY_DEREF(result, value);
40345 } else if (IS_CV == IS_VAR) {
40346 if (UNEXPECTED(Z_ISREF_P(value))) {
40347 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
40348 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
40349 efree_size(Z_REF_P(value), sizeof(zend_reference));
40350 } else if (Z_OPT_REFCOUNTED_P(result)) {
40351 Z_ADDREF_P(result);
40352 }
40353 } else {
40354 ZVAL_COPY_VALUE(result, value);
40355 }
40356 } else {
40357 ZVAL_COPY_VALUE(result, value);
40358 if (IS_CV == IS_CONST) {
40359 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
40360 Z_ADDREF_P(result);
40361 }
40362 }
40363 }
40364 ZEND_VM_NEXT_OPCODE();
40365 }
40366
ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40367 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40368 {
40369 USE_OPLINE
40370 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
40371 zval *val;
40372
40373 SAVE_OPLINE();
40374 val = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40375
40376 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
40377 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
40378
40379 UNDEF_RESULT();
40380 HANDLE_EXCEPTION();
40381 }
40382
40383 yield_from_try_again:
40384 if (Z_TYPE_P(val) == IS_ARRAY) {
40385 ZVAL_COPY_VALUE(&generator->values, val);
40386 if (Z_OPT_REFCOUNTED_P(val)) {
40387 Z_ADDREF_P(val);
40388 }
40389 Z_FE_POS(generator->values) = 0;
40390
40391 } else if (IS_CV != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
40392 zend_class_entry *ce = Z_OBJCE_P(val);
40393 if (ce == zend_ce_generator) {
40394 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
40395
40396 Z_ADDREF_P(val);
40397
40398 if (UNEXPECTED(new_gen->execute_data == NULL)) {
40399 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
40400 zval_ptr_dtor(val);
40401 UNDEF_RESULT();
40402 HANDLE_EXCEPTION();
40403 } else if (Z_ISUNDEF(new_gen->retval)) {
40404 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
40405 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
40406 zval_ptr_dtor(val);
40407 UNDEF_RESULT();
40408 HANDLE_EXCEPTION();
40409 } else {
40410 zend_generator_yield_from(generator, new_gen);
40411 }
40412 } else {
40413 if (RETURN_VALUE_USED(opline)) {
40414 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
40415 }
40416 ZEND_VM_NEXT_OPCODE();
40417 }
40418 } else {
40419 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
40420
40421 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
40422 if (!EG(exception)) {
40423 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
40424 }
40425 UNDEF_RESULT();
40426 HANDLE_EXCEPTION();
40427 }
40428
40429 iter->index = 0;
40430 if (iter->funcs->rewind) {
40431 iter->funcs->rewind(iter);
40432 if (UNEXPECTED(EG(exception) != NULL)) {
40433 OBJ_RELEASE(&iter->std);
40434 UNDEF_RESULT();
40435 HANDLE_EXCEPTION();
40436 }
40437 }
40438
40439 ZVAL_OBJ(&generator->values, &iter->std);
40440 }
40441 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
40442 val = Z_REFVAL_P(val);
40443 goto yield_from_try_again;
40444 } else {
40445 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
40446
40447 UNDEF_RESULT();
40448 HANDLE_EXCEPTION();
40449 }
40450
40451 /* This is the default return value
40452 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
40453 if (RETURN_VALUE_USED(opline)) {
40454 ZVAL_NULL(EX_VAR(opline->result.var));
40455 }
40456
40457 /* This generator has no send target (though the generator we delegate to might have one) */
40458 generator->send_target = NULL;
40459
40460 /* We increment to the next op, so we are at the correct position when the
40461 * generator is resumed. */
40462 ZEND_VM_INC_OPCODE();
40463
40464 /* The GOTO VM uses a local opline variable. We need to set the opline
40465 * variable in execute_data so we don't resume at an old position. */
40466 SAVE_OPLINE();
40467
40468 ZEND_VM_RETURN();
40469 }
40470
ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40471 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40472 {
40473 USE_OPLINE
40474 zval *value;
40475
40476 value = EX_VAR(opline->op1.var);
40477 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
40478 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
40479 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
40480 zval_ptr_dtor_str(value);
40481 }
40482 ZEND_VM_NEXT_OPCODE();
40483 } else {
40484 bool strict;
40485
40486 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
40487 value = Z_REFVAL_P(value);
40488 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
40489 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
40490
40491 ZEND_VM_NEXT_OPCODE();
40492 }
40493 }
40494
40495 SAVE_OPLINE();
40496 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
40497 value = ZVAL_UNDEFINED_OP1();
40498 }
40499 strict = EX_USES_STRICT_TYPES();
40500 do {
40501 if (EXPECTED(!strict)) {
40502 zend_string *str;
40503 zval tmp;
40504
40505 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
40506 zend_error(E_DEPRECATED,
40507 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
40508 ZVAL_LONG(EX_VAR(opline->result.var), 0);
40509 if (UNEXPECTED(EG(exception))) {
40510 HANDLE_EXCEPTION();
40511 }
40512 break;
40513 }
40514
40515 ZVAL_COPY(&tmp, value);
40516 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
40517 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
40518 zval_ptr_dtor(&tmp);
40519 break;
40520 }
40521 zval_ptr_dtor(&tmp);
40522 }
40523 if (!EG(exception)) {
40524 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
40525 }
40526 ZVAL_UNDEF(EX_VAR(opline->result.var));
40527 } while (0);
40528 }
40529
40530 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40531 }
40532
ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40533 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40534 {
40535 USE_OPLINE
40536 zval *value;
40537 int result = 0;
40538
40539 value = EX_VAR(opline->op1.var);
40540 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
40541 type_check_resource:
40542 if (opline->extended_value != MAY_BE_RESOURCE
40543 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
40544 result = 1;
40545 }
40546 } else if ((IS_CV & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
40547 value = Z_REFVAL_P(value);
40548 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
40549 goto type_check_resource;
40550 }
40551 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
40552 result = ((1 << IS_NULL) & opline->extended_value) != 0;
40553 SAVE_OPLINE();
40554 ZVAL_UNDEFINED_OP1();
40555 if (UNEXPECTED(EG(exception))) {
40556 ZVAL_UNDEF(EX_VAR(opline->result.var));
40557 HANDLE_EXCEPTION();
40558 }
40559 }
40560 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
40561 SAVE_OPLINE();
40562
40563 ZEND_VM_SMART_BRANCH(result, 1);
40564 } else {
40565 ZEND_VM_SMART_BRANCH(result, 0);
40566 }
40567 }
40568
ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40569 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40570 {
40571 uint32_t fetch_type;
40572 zend_class_entry *called_scope, *scope;
40573 USE_OPLINE
40574
40575 if (IS_CV != IS_UNUSED) {
40576 SAVE_OPLINE();
40577 zval *op = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40578 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
40579 ZVAL_DEREF(op);
40580 if (Z_TYPE_P(op) != IS_OBJECT) {
40581 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
40582 ZVAL_UNDEF(EX_VAR(opline->result.var));
40583
40584 HANDLE_EXCEPTION();
40585 }
40586 }
40587
40588 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
40589
40590 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40591 }
40592
40593 fetch_type = opline->op1.num;
40594 scope = EX(func)->op_array.scope;
40595 if (UNEXPECTED(scope == NULL)) {
40596 SAVE_OPLINE();
40597 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
40598 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
40599 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
40600 ZVAL_UNDEF(EX_VAR(opline->result.var));
40601 HANDLE_EXCEPTION();
40602 }
40603
40604 switch (fetch_type) {
40605 case ZEND_FETCH_CLASS_SELF:
40606 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
40607 break;
40608 case ZEND_FETCH_CLASS_PARENT:
40609 if (UNEXPECTED(scope->parent == NULL)) {
40610 SAVE_OPLINE();
40611 zend_throw_error(NULL,
40612 "Cannot use \"parent\" when current class scope has no parent");
40613 ZVAL_UNDEF(EX_VAR(opline->result.var));
40614 HANDLE_EXCEPTION();
40615 }
40616 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
40617 break;
40618 case ZEND_FETCH_CLASS_STATIC:
40619 if (Z_TYPE(EX(This)) == IS_OBJECT) {
40620 called_scope = Z_OBJCE(EX(This));
40621 } else {
40622 called_scope = Z_CE(EX(This));
40623 }
40624 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
40625 break;
40626 EMPTY_SWITCH_DEFAULT_CASE()
40627 }
40628 ZEND_VM_NEXT_OPCODE();
40629 }
40630
ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40631 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40632 {
40633 USE_OPLINE
40634 HashTable *ht;
40635 zval *value;
40636 zval *variable_ptr;
40637
40638 variable_ptr = EX_VAR(opline->op1.var);
40639
40640 SAVE_OPLINE();
40641
40642 ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
40643 if (!ht) {
40644 ht = zend_array_dup(EX(func)->op_array.static_variables);
40645 ZEND_MAP_PTR_SET(EX(func)->op_array.static_variables_ptr, ht);
40646 }
40647 ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
40648
40649 value = (zval*)((char*)ht->arData + (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT|ZEND_BIND_EXPLICIT)));
40650
40651 if (opline->extended_value & ZEND_BIND_REF) {
40652 i_zval_ptr_dtor(variable_ptr);
40653 if (UNEXPECTED(!Z_ISREF_P(value))) {
40654 zend_reference *ref = (zend_reference*)emalloc(sizeof(zend_reference));
40655 GC_SET_REFCOUNT(ref, 2);
40656 GC_TYPE_INFO(ref) = GC_REFERENCE;
40657 if (opline->op2_type == IS_UNUSED) {
40658 ZVAL_COPY_VALUE(&ref->val, value);
40659 } else {
40660 ZEND_ASSERT(!Z_REFCOUNTED_P(value));
40661 ZVAL_COPY(&ref->val, get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R));
40662 FREE_OP(opline->op2_type, opline->op2.var);
40663 }
40664 ref->sources.ptr = NULL;
40665 Z_REF_P(value) = ref;
40666 Z_TYPE_INFO_P(value) = IS_REFERENCE_EX;
40667 ZVAL_REF(variable_ptr, ref);
40668 } else {
40669 Z_ADDREF_P(value);
40670 ZVAL_REF(variable_ptr, Z_REF_P(value));
40671 if (opline->op2_type != IS_UNUSED) {
40672 FREE_OP(opline->op2_type, opline->op2.var);
40673 }
40674 }
40675 } else {
40676 i_zval_ptr_dtor(variable_ptr);
40677 ZVAL_COPY(variable_ptr, value);
40678 }
40679
40680 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40681 }
40682
ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40683 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40684 {
40685 USE_OPLINE
40686 HashTable *ht;
40687 zval *value;
40688 zval *variable_ptr;
40689
40690 variable_ptr = EX_VAR(opline->op1.var);
40691
40692 ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
40693 if (!ht) {
40694 ZEND_VM_NEXT_OPCODE();
40695 }
40696 ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
40697
40698 value = (zval*)((char*)ht->arData + opline->extended_value);
40699 if (Z_TYPE_EXTRA_P(value) & IS_STATIC_VAR_UNINITIALIZED) {
40700 ZEND_VM_NEXT_OPCODE();
40701 } else {
40702 SAVE_OPLINE();
40703 zval_ptr_dtor(variable_ptr);
40704 ZEND_ASSERT(Z_TYPE_P(value) == IS_REFERENCE);
40705 Z_ADDREF_P(value);
40706 ZVAL_REF(variable_ptr, Z_REF_P(value));
40707 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 1);
40708 }
40709 }
40710
ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40711 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)
40712 {
40713 USE_OPLINE
40714 zval *var_ptr;
40715
40716 var_ptr = EX_VAR(opline->op1.var);
40717 Z_LVAL_P(var_ptr)++;
40718 if (UNEXPECTED(0)) {
40719 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40720 }
40721 ZEND_VM_NEXT_OPCODE();
40722 }
40723
ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40724 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)
40725 {
40726 USE_OPLINE
40727 zval *var_ptr;
40728
40729 var_ptr = EX_VAR(opline->op1.var);
40730 Z_LVAL_P(var_ptr)++;
40731 if (UNEXPECTED(1)) {
40732 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40733 }
40734 ZEND_VM_NEXT_OPCODE();
40735 }
40736
ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40737 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40738 {
40739 USE_OPLINE
40740 zval *var_ptr;
40741
40742 var_ptr = EX_VAR(opline->op1.var);
40743 fast_long_increment_function(var_ptr);
40744 if (UNEXPECTED(0)) {
40745 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40746 }
40747 ZEND_VM_NEXT_OPCODE();
40748 }
40749
ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40750 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40751 {
40752 USE_OPLINE
40753 zval *var_ptr;
40754
40755 var_ptr = EX_VAR(opline->op1.var);
40756 fast_long_increment_function(var_ptr);
40757 if (UNEXPECTED(1)) {
40758 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40759 }
40760 ZEND_VM_NEXT_OPCODE();
40761 }
40762
ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40763 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)
40764 {
40765 USE_OPLINE
40766 zval *var_ptr;
40767
40768 var_ptr = EX_VAR(opline->op1.var);
40769 Z_LVAL_P(var_ptr)--;
40770 if (UNEXPECTED(0)) {
40771 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40772 }
40773 ZEND_VM_NEXT_OPCODE();
40774 }
40775
ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40776 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)
40777 {
40778 USE_OPLINE
40779 zval *var_ptr;
40780
40781 var_ptr = EX_VAR(opline->op1.var);
40782 Z_LVAL_P(var_ptr)--;
40783 if (UNEXPECTED(1)) {
40784 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40785 }
40786 ZEND_VM_NEXT_OPCODE();
40787 }
40788
ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40789 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40790 {
40791 USE_OPLINE
40792 zval *var_ptr;
40793
40794 var_ptr = EX_VAR(opline->op1.var);
40795 fast_long_decrement_function(var_ptr);
40796 if (UNEXPECTED(0)) {
40797 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40798 }
40799 ZEND_VM_NEXT_OPCODE();
40800 }
40801
ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40802 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40803 {
40804 USE_OPLINE
40805 zval *var_ptr;
40806
40807 var_ptr = EX_VAR(opline->op1.var);
40808 fast_long_decrement_function(var_ptr);
40809 if (UNEXPECTED(1)) {
40810 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40811 }
40812 ZEND_VM_NEXT_OPCODE();
40813 }
40814
ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40815 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40816 {
40817 USE_OPLINE
40818 zval *var_ptr;
40819
40820 var_ptr = EX_VAR(opline->op1.var);
40821 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40822 Z_LVAL_P(var_ptr)++;
40823 ZEND_VM_NEXT_OPCODE();
40824 }
40825
ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40826 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40827 {
40828 USE_OPLINE
40829 zval *var_ptr;
40830
40831 var_ptr = EX_VAR(opline->op1.var);
40832 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40833 fast_long_increment_function(var_ptr);
40834 ZEND_VM_NEXT_OPCODE();
40835 }
40836
ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40837 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40838 {
40839 USE_OPLINE
40840 zval *var_ptr;
40841
40842 var_ptr = EX_VAR(opline->op1.var);
40843 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40844 Z_LVAL_P(var_ptr)--;
40845 ZEND_VM_NEXT_OPCODE();
40846 }
40847
ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40848 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40849 {
40850 USE_OPLINE
40851 zval *var_ptr;
40852
40853 var_ptr = EX_VAR(opline->op1.var);
40854 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40855 fast_long_decrement_function(var_ptr);
40856 ZEND_VM_NEXT_OPCODE();
40857 }
40858
ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40859 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40860 {
40861 USE_OPLINE
40862 zval *varptr, *arg;
40863
40864 varptr = EX_VAR(opline->op1.var);
40865 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
40866
40867 if (IS_CV == IS_CV) {
40868 ZVAL_COPY(arg, varptr);
40869 } else /* if (IS_CV == IS_VAR) */ {
40870 ZVAL_COPY_VALUE(arg, varptr);
40871 }
40872
40873 ZEND_VM_NEXT_OPCODE();
40874 }
40875
ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40876 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40877 {
40878 USE_OPLINE
40879 zval *op1, *op2;
40880
40881 SAVE_OPLINE();
40882 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40883 op2 = RT_CONSTANT(opline, opline->op2);
40884 div_function(EX_VAR(opline->result.var), op1, op2);
40885
40886
40887 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40888 }
40889
ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40890 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40891 {
40892 USE_OPLINE
40893 zval *op1, *op2;
40894
40895 SAVE_OPLINE();
40896 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40897 op2 = RT_CONSTANT(opline, opline->op2);
40898 pow_function(EX_VAR(opline->result.var), op1, op2);
40899
40900
40901 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40902 }
40903
ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40904 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40905 {
40906 USE_OPLINE
40907 zval *op1, *op2;
40908
40909 op1 = EX_VAR(opline->op1.var);
40910 op2 = RT_CONSTANT(opline, opline->op2);
40911
40912 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
40913 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
40914 zend_string *op1_str = Z_STR_P(op1);
40915 zend_string *op2_str = Z_STR_P(op2);
40916 zend_string *str;
40917 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
40918
40919 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
40920 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
40921 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
40922 } else {
40923 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
40924 }
40925 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
40926 zend_string_release_ex(op1_str, 0);
40927 }
40928 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
40929 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
40930 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
40931 } else {
40932 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
40933 }
40934 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
40935 zend_string_release_ex(op2_str, 0);
40936 }
40937 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
40938 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
40939 size_t len = ZSTR_LEN(op1_str);
40940
40941 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
40942 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
40943 }
40944 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
40945 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
40946 GC_ADD_FLAGS(str, flags);
40947 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
40948 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
40949 zend_string_release_ex(op2_str, 0);
40950 }
40951 } else {
40952 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
40953 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
40954 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
40955 GC_ADD_FLAGS(str, flags);
40956 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
40957 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
40958 zend_string_release_ex(op1_str, 0);
40959 }
40960 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
40961 zend_string_release_ex(op2_str, 0);
40962 }
40963 }
40964 ZEND_VM_NEXT_OPCODE();
40965 } else {
40966 SAVE_OPLINE();
40967
40968 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
40969 op1 = ZVAL_UNDEFINED_OP1();
40970 }
40971 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
40972 op2 = ZVAL_UNDEFINED_OP2();
40973 }
40974 concat_function(EX_VAR(opline->result.var), op1, op2);
40975
40976
40977 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40978 }
40979 }
40980
ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40981 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40982 {
40983 USE_OPLINE
40984 zval *op1, *op2;
40985 bool result;
40986
40987 SAVE_OPLINE();
40988 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40989 op2 = RT_CONSTANT(opline, opline->op2);
40990 result = fast_is_identical_function(op1, op2);
40991
40992
40993 ZEND_VM_SMART_BRANCH(result, 1);
40994 }
40995
ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40996 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40997 {
40998 USE_OPLINE
40999 zval *op1, *op2;
41000 bool result;
41001
41002 SAVE_OPLINE();
41003 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41004 op2 = RT_CONSTANT(opline, opline->op2);
41005 result = fast_is_not_identical_function(op1, op2);
41006
41007
41008 ZEND_VM_SMART_BRANCH(result, 1);
41009 }
41010
ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41011 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41012 {
41013 USE_OPLINE
41014 zval *op1, *op2;
41015 double d1, d2;
41016
41017 op1 = EX_VAR(opline->op1.var);
41018 op2 = RT_CONSTANT(opline, opline->op2);
41019 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41020 /* pass */
41021 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41022 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41023 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
41024 is_equal_true:
41025 ZEND_VM_SMART_BRANCH_TRUE_NONE();
41026 } else {
41027 is_equal_false:
41028 ZEND_VM_SMART_BRANCH_FALSE_NONE();
41029 }
41030 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41031 d1 = (double)Z_LVAL_P(op1);
41032 d2 = Z_DVAL_P(op2);
41033 goto is_equal_double;
41034 }
41035 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41036 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41037 d1 = Z_DVAL_P(op1);
41038 d2 = Z_DVAL_P(op2);
41039 is_equal_double:
41040 if (d1 == d2) {
41041 goto is_equal_true;
41042 } else {
41043 goto is_equal_false;
41044 }
41045 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41046 d1 = Z_DVAL_P(op1);
41047 d2 = (double)Z_LVAL_P(op2);
41048 goto is_equal_double;
41049 }
41050 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41051 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41052 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41053 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41054 zval_ptr_dtor_str(op1);
41055 }
41056 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41057 zval_ptr_dtor_str(op2);
41058 }
41059 if (result) {
41060 goto is_equal_true;
41061 } else {
41062 goto is_equal_false;
41063 }
41064 }
41065 }
41066 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41067 }
41068
ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41069 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41070 {
41071 USE_OPLINE
41072 zval *op1, *op2;
41073 double d1, d2;
41074
41075 op1 = EX_VAR(opline->op1.var);
41076 op2 = RT_CONSTANT(opline, opline->op2);
41077 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41078 /* pass */
41079 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41080 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41081 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
41082 is_equal_true:
41083 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
41084 } else {
41085 is_equal_false:
41086 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
41087 }
41088 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41089 d1 = (double)Z_LVAL_P(op1);
41090 d2 = Z_DVAL_P(op2);
41091 goto is_equal_double;
41092 }
41093 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41094 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41095 d1 = Z_DVAL_P(op1);
41096 d2 = Z_DVAL_P(op2);
41097 is_equal_double:
41098 if (d1 == d2) {
41099 goto is_equal_true;
41100 } else {
41101 goto is_equal_false;
41102 }
41103 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41104 d1 = Z_DVAL_P(op1);
41105 d2 = (double)Z_LVAL_P(op2);
41106 goto is_equal_double;
41107 }
41108 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41109 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41110 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41111 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41112 zval_ptr_dtor_str(op1);
41113 }
41114 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41115 zval_ptr_dtor_str(op2);
41116 }
41117 if (result) {
41118 goto is_equal_true;
41119 } else {
41120 goto is_equal_false;
41121 }
41122 }
41123 }
41124 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41125 }
41126
ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41127 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41128 {
41129 USE_OPLINE
41130 zval *op1, *op2;
41131 double d1, d2;
41132
41133 op1 = EX_VAR(opline->op1.var);
41134 op2 = RT_CONSTANT(opline, opline->op2);
41135 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41136 /* pass */
41137 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41138 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41139 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
41140 is_equal_true:
41141 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
41142 } else {
41143 is_equal_false:
41144 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
41145 }
41146 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41147 d1 = (double)Z_LVAL_P(op1);
41148 d2 = Z_DVAL_P(op2);
41149 goto is_equal_double;
41150 }
41151 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41152 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41153 d1 = Z_DVAL_P(op1);
41154 d2 = Z_DVAL_P(op2);
41155 is_equal_double:
41156 if (d1 == d2) {
41157 goto is_equal_true;
41158 } else {
41159 goto is_equal_false;
41160 }
41161 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41162 d1 = Z_DVAL_P(op1);
41163 d2 = (double)Z_LVAL_P(op2);
41164 goto is_equal_double;
41165 }
41166 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41167 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41168 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41169 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41170 zval_ptr_dtor_str(op1);
41171 }
41172 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41173 zval_ptr_dtor_str(op2);
41174 }
41175 if (result) {
41176 goto is_equal_true;
41177 } else {
41178 goto is_equal_false;
41179 }
41180 }
41181 }
41182 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41183 }
41184
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41185 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41186 {
41187 USE_OPLINE
41188 zval *op1, *op2;
41189 double d1, d2;
41190
41191 op1 = EX_VAR(opline->op1.var);
41192 op2 = RT_CONSTANT(opline, opline->op2);
41193 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41194 /* pass */
41195 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41196 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41197 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
41198 is_not_equal_true:
41199 ZEND_VM_SMART_BRANCH_TRUE_NONE();
41200 } else {
41201 is_not_equal_false:
41202 ZEND_VM_SMART_BRANCH_FALSE_NONE();
41203 }
41204 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41205 d1 = (double)Z_LVAL_P(op1);
41206 d2 = Z_DVAL_P(op2);
41207 goto is_not_equal_double;
41208 }
41209 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41210 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41211 d1 = Z_DVAL_P(op1);
41212 d2 = Z_DVAL_P(op2);
41213 is_not_equal_double:
41214 if (d1 != d2) {
41215 goto is_not_equal_true;
41216 } else {
41217 goto is_not_equal_false;
41218 }
41219 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41220 d1 = Z_DVAL_P(op1);
41221 d2 = (double)Z_LVAL_P(op2);
41222 goto is_not_equal_double;
41223 }
41224 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41225 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41226 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41227 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41228 zval_ptr_dtor_str(op1);
41229 }
41230 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41231 zval_ptr_dtor_str(op2);
41232 }
41233 if (!result) {
41234 goto is_not_equal_true;
41235 } else {
41236 goto is_not_equal_false;
41237 }
41238 }
41239 }
41240 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41241 }
41242
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41243 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41244 {
41245 USE_OPLINE
41246 zval *op1, *op2;
41247 double d1, d2;
41248
41249 op1 = EX_VAR(opline->op1.var);
41250 op2 = RT_CONSTANT(opline, opline->op2);
41251 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41252 /* pass */
41253 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41254 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41255 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
41256 is_not_equal_true:
41257 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
41258 } else {
41259 is_not_equal_false:
41260 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
41261 }
41262 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41263 d1 = (double)Z_LVAL_P(op1);
41264 d2 = Z_DVAL_P(op2);
41265 goto is_not_equal_double;
41266 }
41267 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41268 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41269 d1 = Z_DVAL_P(op1);
41270 d2 = Z_DVAL_P(op2);
41271 is_not_equal_double:
41272 if (d1 != d2) {
41273 goto is_not_equal_true;
41274 } else {
41275 goto is_not_equal_false;
41276 }
41277 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41278 d1 = Z_DVAL_P(op1);
41279 d2 = (double)Z_LVAL_P(op2);
41280 goto is_not_equal_double;
41281 }
41282 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41283 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41284 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41285 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41286 zval_ptr_dtor_str(op1);
41287 }
41288 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41289 zval_ptr_dtor_str(op2);
41290 }
41291 if (!result) {
41292 goto is_not_equal_true;
41293 } else {
41294 goto is_not_equal_false;
41295 }
41296 }
41297 }
41298 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41299 }
41300
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41301 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41302 {
41303 USE_OPLINE
41304 zval *op1, *op2;
41305 double d1, d2;
41306
41307 op1 = EX_VAR(opline->op1.var);
41308 op2 = RT_CONSTANT(opline, opline->op2);
41309 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41310 /* pass */
41311 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41312 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41313 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
41314 is_not_equal_true:
41315 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
41316 } else {
41317 is_not_equal_false:
41318 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
41319 }
41320 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41321 d1 = (double)Z_LVAL_P(op1);
41322 d2 = Z_DVAL_P(op2);
41323 goto is_not_equal_double;
41324 }
41325 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41326 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41327 d1 = Z_DVAL_P(op1);
41328 d2 = Z_DVAL_P(op2);
41329 is_not_equal_double:
41330 if (d1 != d2) {
41331 goto is_not_equal_true;
41332 } else {
41333 goto is_not_equal_false;
41334 }
41335 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41336 d1 = Z_DVAL_P(op1);
41337 d2 = (double)Z_LVAL_P(op2);
41338 goto is_not_equal_double;
41339 }
41340 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41341 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41342 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41343 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41344 zval_ptr_dtor_str(op1);
41345 }
41346 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41347 zval_ptr_dtor_str(op2);
41348 }
41349 if (!result) {
41350 goto is_not_equal_true;
41351 } else {
41352 goto is_not_equal_false;
41353 }
41354 }
41355 }
41356 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41357 }
41358
ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41359 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41360 {
41361 USE_OPLINE
41362 zval *op1, *op2;
41363
41364 SAVE_OPLINE();
41365 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41366 op2 = RT_CONSTANT(opline, opline->op2);
41367 compare_function(EX_VAR(opline->result.var), op1, op2);
41368
41369
41370 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41371 }
41372
ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41373 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41374 {
41375 USE_OPLINE
41376 zval *op1, *op2;
41377
41378 SAVE_OPLINE();
41379 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41380 op2 = RT_CONSTANT(opline, opline->op2);
41381 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
41382
41383
41384 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41385 }
41386
ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41387 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41388 {
41389 USE_OPLINE
41390 zval *object;
41391 zval *property;
41392 zval *value;
41393 zval *zptr;
41394 void **cache_slot;
41395 zend_property_info *prop_info;
41396 zend_object *zobj;
41397 zend_string *name, *tmp_name;
41398
41399 SAVE_OPLINE();
41400 object = EX_VAR(opline->op1.var);
41401 property = RT_CONSTANT(opline, opline->op2);
41402
41403 do {
41404 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
41405
41406 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
41407 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
41408 object = Z_REFVAL_P(object);
41409 goto assign_op_object;
41410 }
41411 if (IS_CV == IS_CV
41412 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
41413 ZVAL_UNDEFINED_OP1();
41414 }
41415 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
41416 break;
41417 }
41418
41419 assign_op_object:
41420 /* here we are sure we are dealing with an object */
41421 zobj = Z_OBJ_P(object);
41422 if (IS_CONST == IS_CONST) {
41423 name = Z_STR_P(property);
41424 } else {
41425 name = zval_try_get_tmp_string(property, &tmp_name);
41426 if (UNEXPECTED(!name)) {
41427 UNDEF_RESULT();
41428 break;
41429 }
41430 }
41431 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
41432 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
41433 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
41434 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41435 ZVAL_NULL(EX_VAR(opline->result.var));
41436 }
41437 } else {
41438 zval *orig_zptr = zptr;
41439 zend_reference *ref;
41440
41441 do {
41442 if (UNEXPECTED(Z_ISREF_P(zptr))) {
41443 ref = Z_REF_P(zptr);
41444 zptr = Z_REFVAL_P(zptr);
41445 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
41446 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
41447 break;
41448 }
41449 }
41450
41451 if (IS_CONST == IS_CONST) {
41452 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
41453 } else {
41454 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
41455 }
41456 if (prop_info) {
41457 /* special case for typed properties */
41458 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
41459 } else {
41460 zend_binary_op(zptr, zptr, value OPLINE_CC);
41461 }
41462 } while (0);
41463
41464 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41465 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
41466 }
41467 }
41468 } else {
41469 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
41470 }
41471 if (IS_CONST != IS_CONST) {
41472 zend_tmp_string_release(tmp_name);
41473 }
41474 } while (0);
41475
41476 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
41477
41478
41479 /* assign_obj has two opcodes! */
41480 ZEND_VM_NEXT_OPCODE_EX(1, 2);
41481 }
41482
41483 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41484 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41485 {
41486 USE_OPLINE
41487 zval *var_ptr;
41488 zval *value, *container, *dim;
41489 HashTable *ht;
41490
41491 SAVE_OPLINE();
41492 container = EX_VAR(opline->op1.var);
41493
41494 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
41495 assign_dim_op_array:
41496 SEPARATE_ARRAY(container);
41497 ht = Z_ARRVAL_P(container);
41498 assign_dim_op_new_array:
41499 dim = RT_CONSTANT(opline, opline->op2);
41500 if (IS_CONST == IS_UNUSED) {
41501 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
41502 if (UNEXPECTED(!var_ptr)) {
41503 zend_cannot_add_element();
41504 goto assign_dim_op_ret_null;
41505 }
41506 } else {
41507 if (IS_CONST == IS_CONST) {
41508 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
41509 } else {
41510 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
41511 }
41512 if (UNEXPECTED(!var_ptr)) {
41513 goto assign_dim_op_ret_null;
41514 }
41515 }
41516
41517 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
41518
41519 do {
41520 if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
41521 zend_reference *ref = Z_REF_P(var_ptr);
41522 var_ptr = Z_REFVAL_P(var_ptr);
41523 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
41524 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
41525 break;
41526 }
41527 }
41528 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
41529 } while (0);
41530
41531 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41532 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
41533 }
41534 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
41535 } else {
41536 if (EXPECTED(Z_ISREF_P(container))) {
41537 container = Z_REFVAL_P(container);
41538 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
41539 goto assign_dim_op_array;
41540 }
41541 }
41542
41543 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
41544 zend_object *obj = Z_OBJ_P(container);
41545
41546 dim = RT_CONSTANT(opline, opline->op2);
41547 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
41548 dim++;
41549 }
41550 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
41551 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
41552 uint8_t old_type;
41553
41554 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
41555 ZVAL_UNDEFINED_OP1();
41556 }
41557 ht = zend_new_array(8);
41558 old_type = Z_TYPE_P(container);
41559 ZVAL_ARR(container, ht);
41560 if (UNEXPECTED(old_type == IS_FALSE)) {
41561 GC_ADDREF(ht);
41562 zend_false_to_array_deprecated();
41563 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
41564 zend_array_destroy(ht);
41565 goto assign_dim_op_ret_null;
41566 }
41567 }
41568 goto assign_dim_op_new_array;
41569 } else {
41570 dim = RT_CONSTANT(opline, opline->op2);
41571 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
41572 assign_dim_op_ret_null:
41573 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
41574 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41575 ZVAL_NULL(EX_VAR(opline->result.var));
41576 }
41577 }
41578 }
41579
41580
41581 ZEND_VM_NEXT_OPCODE_EX(1, 2);
41582 }
41583
ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41584 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41585 {
41586 USE_OPLINE
41587 zval *var_ptr;
41588 zval *value;
41589
41590 SAVE_OPLINE();
41591 value = RT_CONSTANT(opline, opline->op2);
41592 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
41593
41594 do {
41595 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
41596 zend_reference *ref = Z_REF_P(var_ptr);
41597 var_ptr = Z_REFVAL_P(var_ptr);
41598 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
41599 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
41600 break;
41601 }
41602 }
41603 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
41604 } while (0);
41605
41606 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41607 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
41608 }
41609
41610
41611 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41612 }
41613
ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41614 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41615 {
41616 USE_OPLINE
41617 zval *object;
41618 zval *property;
41619 zval *zptr;
41620 void **cache_slot;
41621 zend_property_info *prop_info;
41622 zend_object *zobj;
41623 zend_string *name, *tmp_name;
41624
41625 SAVE_OPLINE();
41626 object = EX_VAR(opline->op1.var);
41627 property = RT_CONSTANT(opline, opline->op2);
41628
41629 do {
41630 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
41631 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
41632 object = Z_REFVAL_P(object);
41633 goto pre_incdec_object;
41634 }
41635 if (IS_CV == IS_CV
41636 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
41637 ZVAL_UNDEFINED_OP1();
41638 }
41639 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
41640 break;
41641 }
41642
41643 pre_incdec_object:
41644 /* here we are sure we are dealing with an object */
41645 zobj = Z_OBJ_P(object);
41646 if (IS_CONST == IS_CONST) {
41647 name = Z_STR_P(property);
41648 } else {
41649 name = zval_try_get_tmp_string(property, &tmp_name);
41650 if (UNEXPECTED(!name)) {
41651 UNDEF_RESULT();
41652 break;
41653 }
41654 }
41655 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
41656 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
41657 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
41658 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41659 ZVAL_NULL(EX_VAR(opline->result.var));
41660 }
41661 } else {
41662 if (IS_CONST == IS_CONST) {
41663 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
41664 } else {
41665 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
41666 }
41667 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
41668 }
41669 } else {
41670 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
41671 }
41672 if (IS_CONST != IS_CONST) {
41673 zend_tmp_string_release(tmp_name);
41674 }
41675 } while (0);
41676
41677
41678 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41679 }
41680
ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41681 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41682 {
41683 USE_OPLINE
41684 zval *object;
41685 zval *property;
41686 zval *zptr;
41687 void **cache_slot;
41688 zend_property_info *prop_info;
41689 zend_object *zobj;
41690 zend_string *name, *tmp_name;
41691
41692 SAVE_OPLINE();
41693 object = EX_VAR(opline->op1.var);
41694 property = RT_CONSTANT(opline, opline->op2);
41695
41696 do {
41697 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
41698 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
41699 object = Z_REFVAL_P(object);
41700 goto post_incdec_object;
41701 }
41702 if (IS_CV == IS_CV
41703 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
41704 ZVAL_UNDEFINED_OP1();
41705 }
41706 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
41707 break;
41708 }
41709
41710 post_incdec_object:
41711 /* here we are sure we are dealing with an object */
41712 zobj = Z_OBJ_P(object);
41713 if (IS_CONST == IS_CONST) {
41714 name = Z_STR_P(property);
41715 } else {
41716 name = zval_try_get_tmp_string(property, &tmp_name);
41717 if (UNEXPECTED(!name)) {
41718 ZVAL_UNDEF(EX_VAR(opline->result.var));
41719 break;
41720 }
41721 }
41722 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
41723 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
41724 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
41725 ZVAL_NULL(EX_VAR(opline->result.var));
41726 } else {
41727 if (IS_CONST == IS_CONST) {
41728 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
41729 } else {
41730 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
41731 }
41732
41733 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
41734 }
41735 } else {
41736 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
41737 }
41738 if (IS_CONST != IS_CONST) {
41739 zend_tmp_string_release(tmp_name);
41740 }
41741 } while (0);
41742
41743
41744 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41745 }
41746
ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41747 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41748 {
41749 USE_OPLINE
41750 zval *container, *dim, *value;
41751
41752 SAVE_OPLINE();
41753 container = EX_VAR(opline->op1.var);
41754 dim = RT_CONSTANT(opline, opline->op2);
41755 if (IS_CV != IS_CONST) {
41756 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
41757 fetch_dim_r_array:
41758 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
41759 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
41760 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
41761 container = Z_REFVAL_P(container);
41762 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
41763 goto fetch_dim_r_array;
41764 } else {
41765 goto fetch_dim_r_slow;
41766 }
41767 } else {
41768 fetch_dim_r_slow:
41769 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
41770 dim++;
41771 }
41772 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
41773 }
41774 } else {
41775 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
41776 }
41777
41778
41779 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41780 }
41781
ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41782 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41783 {
41784 USE_OPLINE
41785 zval *container;
41786
41787 SAVE_OPLINE();
41788 container = EX_VAR(opline->op1.var);
41789 zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
41790
41791 if (IS_CV == IS_VAR) {
41792 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
41793 }
41794 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41795 }
41796
ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41797 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41798 {
41799 USE_OPLINE
41800 zval *container;
41801
41802 SAVE_OPLINE();
41803 container = EX_VAR(opline->op1.var);
41804 zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
41805
41806 if (IS_CV == IS_VAR) {
41807 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
41808 }
41809 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41810 }
41811
ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41812 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41813 {
41814 USE_OPLINE
41815 zval *container;
41816
41817 SAVE_OPLINE();
41818 container = EX_VAR(opline->op1.var);
41819 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
41820
41821
41822 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41823 }
41824
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41825 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41826 {
41827 #if 0
41828 USE_OPLINE
41829 #endif
41830
41831 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
41832 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
41833 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
41834 }
41835 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
41836 } else {
41837 if (IS_CONST == IS_UNUSED) {
41838 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
41839 }
41840 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
41841 }
41842 }
41843
ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41844 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41845 {
41846 USE_OPLINE
41847 zval *container;
41848
41849 SAVE_OPLINE();
41850 container = EX_VAR(opline->op1.var);
41851 zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
41852
41853 if (IS_CV == IS_VAR) {
41854 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
41855 }
41856 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41857 }
41858
ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41859 static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41860 {
41861 USE_OPLINE
41862 zval *container;
41863 void **cache_slot = NULL;
41864
41865 SAVE_OPLINE();
41866 container = EX_VAR(opline->op1.var);
41867
41868 if (IS_CV == IS_CONST ||
41869 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
41870 do {
41871 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
41872 container = Z_REFVAL_P(container);
41873 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
41874 break;
41875 }
41876 }
41877 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
41878 ZVAL_UNDEFINED_OP1();
41879 }
41880 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
41881 ZVAL_NULL(EX_VAR(opline->result.var));
41882 goto fetch_obj_r_finish;
41883 } while (0);
41884 }
41885
41886 /* here we are sure we are dealing with an object */
41887 do {
41888 zend_object *zobj = Z_OBJ_P(container);
41889 zend_string *name, *tmp_name;
41890 zval *retval;
41891
41892 if (IS_CONST == IS_CONST) {
41893 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
41894
41895 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
41896 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
41897
41898 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
41899 retval = OBJ_PROP(zobj, prop_offset);
41900 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
41901 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
41902 goto fetch_obj_r_copy;
41903 } else {
41904 fetch_obj_r_fast_copy:
41905 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
41906 ZEND_VM_NEXT_OPCODE();
41907 }
41908 }
41909 } else if (EXPECTED(zobj->properties != NULL)) {
41910 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
41911 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
41912 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
41913
41914 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
41915 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
41916
41917 if (EXPECTED(p->key == name) ||
41918 (EXPECTED(p->h == ZSTR_H(name)) &&
41919 EXPECTED(p->key != NULL) &&
41920 EXPECTED(zend_string_equal_content(p->key, name)))) {
41921 retval = &p->val;
41922 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
41923 goto fetch_obj_r_copy;
41924 } else {
41925 goto fetch_obj_r_fast_copy;
41926 }
41927 }
41928 }
41929 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
41930 }
41931 retval = zend_hash_find_known_hash(zobj->properties, name);
41932 if (EXPECTED(retval)) {
41933 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
41934 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
41935 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
41936 goto fetch_obj_r_copy;
41937 } else {
41938 goto fetch_obj_r_fast_copy;
41939 }
41940 }
41941 }
41942 }
41943 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
41944 } else {
41945 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
41946 if (UNEXPECTED(!name)) {
41947 ZVAL_UNDEF(EX_VAR(opline->result.var));
41948 break;
41949 }
41950 }
41951
41952 #if ZEND_DEBUG
41953 /* For non-standard object handlers, verify a declared property type in debug builds.
41954 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
41955 zend_property_info *prop_info = NULL;
41956 if (zobj->handlers->read_property != zend_std_read_property) {
41957 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
41958 }
41959 #endif
41960 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
41961 #if ZEND_DEBUG
41962 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
41963 && ZEND_TYPE_IS_SET(prop_info->type)) {
41964 ZVAL_OPT_DEREF(retval);
41965 zend_verify_property_type(prop_info, retval, /* strict */ true);
41966 }
41967 #endif
41968
41969 if (IS_CONST != IS_CONST) {
41970 zend_tmp_string_release(tmp_name);
41971 }
41972
41973 if (retval != EX_VAR(opline->result.var)) {
41974 fetch_obj_r_copy:
41975 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
41976 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
41977 zend_unwrap_reference(retval);
41978 }
41979 } while (0);
41980
41981 fetch_obj_r_finish:
41982
41983
41984 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41985 }
41986
ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41987 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41988 {
41989 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
41990 }
41991
ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41992 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41993 {
41994 USE_OPLINE
41995 zval *property, *container, *result;
41996
41997 SAVE_OPLINE();
41998
41999 container = EX_VAR(opline->op1.var);
42000 property = RT_CONSTANT(opline, opline->op2);
42001 result = EX_VAR(opline->result.var);
42002 zend_fetch_property_address(
42003 result, container, IS_CV, property, IS_CONST,
42004 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
42005 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
42006
42007 if (IS_CV == IS_VAR) {
42008 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42009 }
42010 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42011 }
42012
ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42013 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42014 {
42015 USE_OPLINE
42016 zval *property, *container, *result;
42017
42018 SAVE_OPLINE();
42019 container = EX_VAR(opline->op1.var);
42020 property = RT_CONSTANT(opline, opline->op2);
42021 result = EX_VAR(opline->result.var);
42022 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);
42023
42024 if (IS_CV == IS_VAR) {
42025 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42026 }
42027 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42028 }
42029
ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42030 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42031 {
42032 USE_OPLINE
42033 zval *container;
42034 void **cache_slot = NULL;
42035
42036 SAVE_OPLINE();
42037 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
42038
42039 if (IS_CV == IS_CONST ||
42040 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
42041 do {
42042 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
42043 container = Z_REFVAL_P(container);
42044 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
42045 break;
42046 }
42047 }
42048 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
42049 ZVAL_UNDEFINED_OP2();
42050 }
42051 ZVAL_NULL(EX_VAR(opline->result.var));
42052 goto fetch_obj_is_finish;
42053 } while (0);
42054 }
42055
42056 /* here we are sure we are dealing with an object */
42057 do {
42058 zend_object *zobj = Z_OBJ_P(container);
42059 zend_string *name, *tmp_name;
42060 zval *retval;
42061
42062 if (IS_CONST == IS_CONST) {
42063 cache_slot = CACHE_ADDR(opline->extended_value);
42064
42065 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
42066 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42067
42068 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42069 retval = OBJ_PROP(zobj, prop_offset);
42070 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
42071 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
42072 goto fetch_obj_is_copy;
42073 } else {
42074 fetch_obj_is_fast_copy:
42075 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
42076 ZEND_VM_NEXT_OPCODE();
42077 }
42078 }
42079 } else if (EXPECTED(zobj->properties != NULL)) {
42080 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42081 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
42082 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
42083
42084 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
42085 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
42086
42087 if (EXPECTED(p->key == name) ||
42088 (EXPECTED(p->h == ZSTR_H(name)) &&
42089 EXPECTED(p->key != NULL) &&
42090 EXPECTED(zend_string_equal_content(p->key, name)))) {
42091 retval = &p->val;
42092 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
42093 goto fetch_obj_is_copy;
42094 } else {
42095 goto fetch_obj_is_fast_copy;
42096 }
42097 }
42098 }
42099 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
42100 }
42101 retval = zend_hash_find_known_hash(zobj->properties, name);
42102 if (EXPECTED(retval)) {
42103 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
42104 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
42105 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
42106 goto fetch_obj_is_copy;
42107 } else {
42108 goto fetch_obj_is_fast_copy;
42109 }
42110 }
42111 }
42112 }
42113 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42114 } else {
42115 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
42116 if (UNEXPECTED(!name)) {
42117 ZVAL_UNDEF(EX_VAR(opline->result.var));
42118 break;
42119 }
42120 }
42121
42122 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
42123
42124 if (IS_CONST != IS_CONST) {
42125 zend_tmp_string_release(tmp_name);
42126 }
42127
42128 if (retval != EX_VAR(opline->result.var)) {
42129 fetch_obj_is_copy:
42130 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
42131 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
42132 zend_unwrap_reference(retval);
42133 }
42134 } while (0);
42135
42136 fetch_obj_is_finish:
42137
42138
42139 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42140 }
42141
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42142 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42143 {
42144 #if 0
42145 USE_OPLINE
42146 #endif
42147
42148 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
42149 /* Behave like FETCH_OBJ_W */
42150 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
42151 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42152 }
42153 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42154 } else {
42155 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42156 }
42157 }
42158
ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42159 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42160 {
42161 USE_OPLINE
42162 zval *container, *property, *result;
42163
42164 SAVE_OPLINE();
42165 container = EX_VAR(opline->op1.var);
42166 property = RT_CONSTANT(opline, opline->op2);
42167 result = EX_VAR(opline->result.var);
42168 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);
42169
42170 if (IS_CV == IS_VAR) {
42171 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42172 }
42173 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42174 }
42175
ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42176 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42177 {
42178 USE_OPLINE
42179 zval *object, *value, tmp;
42180 zend_object *zobj;
42181 zend_string *name, *tmp_name;
42182 zend_refcounted *garbage = NULL;
42183
42184 SAVE_OPLINE();
42185 object = EX_VAR(opline->op1.var);
42186 value = RT_CONSTANT((opline+1), (opline+1)->op1);
42187
42188 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42189 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42190 object = Z_REFVAL_P(object);
42191 goto assign_object;
42192 }
42193 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
42194 value = &EG(uninitialized_zval);
42195 goto free_and_exit_assign_obj;
42196 }
42197
42198 assign_object:
42199 zobj = Z_OBJ_P(object);
42200 if (IS_CONST == IS_CONST) {
42201 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
42202 void **cache_slot = CACHE_ADDR(opline->extended_value);
42203 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42204 zval *property_val;
42205
42206 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42207 property_val = OBJ_PROP(zobj, prop_offset);
42208 if (Z_TYPE_P(property_val) != IS_UNDEF) {
42209 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
42210
42211 if (prop_info != NULL) {
42212 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
42213 goto free_and_exit_assign_obj;
42214 } else {
42215 fast_assign_obj:
42216 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
42217 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42218 ZVAL_COPY(EX_VAR(opline->result.var), value);
42219 }
42220 goto exit_assign_obj;
42221 }
42222 }
42223 } else {
42224 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42225 if (EXPECTED(zobj->properties != NULL)) {
42226 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
42227 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
42228 GC_DELREF(zobj->properties);
42229 }
42230 zobj->properties = zend_array_dup(zobj->properties);
42231 }
42232 property_val = zend_hash_find_known_hash(zobj->properties, name);
42233 if (property_val) {
42234 goto fast_assign_obj;
42235 }
42236 }
42237
42238 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
42239 if (EXPECTED(zobj->properties == NULL)) {
42240 rebuild_object_properties(zobj);
42241 }
42242 if (IS_CONST == IS_CONST) {
42243 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
42244 Z_ADDREF_P(value);
42245 }
42246 } else if (IS_CONST != IS_TMP_VAR) {
42247 if (Z_ISREF_P(value)) {
42248 if (IS_CONST == IS_VAR) {
42249 zend_reference *ref = Z_REF_P(value);
42250 if (GC_DELREF(ref) == 0) {
42251 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
42252 efree_size(ref, sizeof(zend_reference));
42253 value = &tmp;
42254 } else {
42255 value = Z_REFVAL_P(value);
42256 Z_TRY_ADDREF_P(value);
42257 }
42258 } else {
42259 value = Z_REFVAL_P(value);
42260 Z_TRY_ADDREF_P(value);
42261 }
42262 } else if (IS_CONST == IS_CV) {
42263 Z_TRY_ADDREF_P(value);
42264 }
42265 }
42266 zend_hash_add_new(zobj->properties, name, value);
42267 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42268 ZVAL_COPY(EX_VAR(opline->result.var), value);
42269 }
42270 goto exit_assign_obj;
42271 }
42272 }
42273 }
42274 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42275 } else {
42276 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
42277 if (UNEXPECTED(!name)) {
42278
42279 UNDEF_RESULT();
42280 goto exit_assign_obj;
42281 }
42282 }
42283
42284 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
42285 ZVAL_DEREF(value);
42286 }
42287
42288 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
42289
42290 if (IS_CONST != IS_CONST) {
42291 zend_tmp_string_release(tmp_name);
42292 }
42293
42294 free_and_exit_assign_obj:
42295 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
42296 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42297 }
42298
42299 exit_assign_obj:
42300 if (garbage) {
42301 GC_DTOR_NO_REF(garbage);
42302 }
42303
42304
42305 /* assign_obj has two opcodes! */
42306 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42307 }
42308
42309 /* 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)42310 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42311 {
42312 USE_OPLINE
42313 zval *object, *value, tmp;
42314 zend_object *zobj;
42315 zend_string *name, *tmp_name;
42316 zend_refcounted *garbage = NULL;
42317
42318 SAVE_OPLINE();
42319 object = EX_VAR(opline->op1.var);
42320 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
42321
42322 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42323 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42324 object = Z_REFVAL_P(object);
42325 goto assign_object;
42326 }
42327 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
42328 value = &EG(uninitialized_zval);
42329 goto free_and_exit_assign_obj;
42330 }
42331
42332 assign_object:
42333 zobj = Z_OBJ_P(object);
42334 if (IS_CONST == IS_CONST) {
42335 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
42336 void **cache_slot = CACHE_ADDR(opline->extended_value);
42337 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42338 zval *property_val;
42339
42340 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42341 property_val = OBJ_PROP(zobj, prop_offset);
42342 if (Z_TYPE_P(property_val) != IS_UNDEF) {
42343 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
42344
42345 if (prop_info != NULL) {
42346 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
42347 goto free_and_exit_assign_obj;
42348 } else {
42349 fast_assign_obj:
42350 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
42351 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42352 ZVAL_COPY(EX_VAR(opline->result.var), value);
42353 }
42354 goto exit_assign_obj;
42355 }
42356 }
42357 } else {
42358 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42359 if (EXPECTED(zobj->properties != NULL)) {
42360 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
42361 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
42362 GC_DELREF(zobj->properties);
42363 }
42364 zobj->properties = zend_array_dup(zobj->properties);
42365 }
42366 property_val = zend_hash_find_known_hash(zobj->properties, name);
42367 if (property_val) {
42368 goto fast_assign_obj;
42369 }
42370 }
42371
42372 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
42373 if (EXPECTED(zobj->properties == NULL)) {
42374 rebuild_object_properties(zobj);
42375 }
42376 if (IS_TMP_VAR == IS_CONST) {
42377 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
42378 Z_ADDREF_P(value);
42379 }
42380 } else if (IS_TMP_VAR != IS_TMP_VAR) {
42381 if (Z_ISREF_P(value)) {
42382 if (IS_TMP_VAR == IS_VAR) {
42383 zend_reference *ref = Z_REF_P(value);
42384 if (GC_DELREF(ref) == 0) {
42385 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
42386 efree_size(ref, sizeof(zend_reference));
42387 value = &tmp;
42388 } else {
42389 value = Z_REFVAL_P(value);
42390 Z_TRY_ADDREF_P(value);
42391 }
42392 } else {
42393 value = Z_REFVAL_P(value);
42394 Z_TRY_ADDREF_P(value);
42395 }
42396 } else if (IS_TMP_VAR == IS_CV) {
42397 Z_TRY_ADDREF_P(value);
42398 }
42399 }
42400 zend_hash_add_new(zobj->properties, name, value);
42401 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42402 ZVAL_COPY(EX_VAR(opline->result.var), value);
42403 }
42404 goto exit_assign_obj;
42405 }
42406 }
42407 }
42408 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42409 } else {
42410 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
42411 if (UNEXPECTED(!name)) {
42412 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42413 UNDEF_RESULT();
42414 goto exit_assign_obj;
42415 }
42416 }
42417
42418 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
42419 ZVAL_DEREF(value);
42420 }
42421
42422 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
42423
42424 if (IS_CONST != IS_CONST) {
42425 zend_tmp_string_release(tmp_name);
42426 }
42427
42428 free_and_exit_assign_obj:
42429 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
42430 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42431 }
42432 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42433 exit_assign_obj:
42434 if (garbage) {
42435 GC_DTOR_NO_REF(garbage);
42436 }
42437
42438
42439 /* assign_obj has two opcodes! */
42440 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42441 }
42442
42443 /* 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)42444 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42445 {
42446 USE_OPLINE
42447 zval *object, *value, tmp;
42448 zend_object *zobj;
42449 zend_string *name, *tmp_name;
42450 zend_refcounted *garbage = NULL;
42451
42452 SAVE_OPLINE();
42453 object = EX_VAR(opline->op1.var);
42454 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
42455
42456 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42457 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42458 object = Z_REFVAL_P(object);
42459 goto assign_object;
42460 }
42461 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
42462 value = &EG(uninitialized_zval);
42463 goto free_and_exit_assign_obj;
42464 }
42465
42466 assign_object:
42467 zobj = Z_OBJ_P(object);
42468 if (IS_CONST == IS_CONST) {
42469 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
42470 void **cache_slot = CACHE_ADDR(opline->extended_value);
42471 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42472 zval *property_val;
42473
42474 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42475 property_val = OBJ_PROP(zobj, prop_offset);
42476 if (Z_TYPE_P(property_val) != IS_UNDEF) {
42477 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
42478
42479 if (prop_info != NULL) {
42480 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
42481 goto free_and_exit_assign_obj;
42482 } else {
42483 fast_assign_obj:
42484 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
42485 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42486 ZVAL_COPY(EX_VAR(opline->result.var), value);
42487 }
42488 goto exit_assign_obj;
42489 }
42490 }
42491 } else {
42492 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42493 if (EXPECTED(zobj->properties != NULL)) {
42494 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
42495 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
42496 GC_DELREF(zobj->properties);
42497 }
42498 zobj->properties = zend_array_dup(zobj->properties);
42499 }
42500 property_val = zend_hash_find_known_hash(zobj->properties, name);
42501 if (property_val) {
42502 goto fast_assign_obj;
42503 }
42504 }
42505
42506 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
42507 if (EXPECTED(zobj->properties == NULL)) {
42508 rebuild_object_properties(zobj);
42509 }
42510 if (IS_VAR == IS_CONST) {
42511 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
42512 Z_ADDREF_P(value);
42513 }
42514 } else if (IS_VAR != IS_TMP_VAR) {
42515 if (Z_ISREF_P(value)) {
42516 if (IS_VAR == IS_VAR) {
42517 zend_reference *ref = Z_REF_P(value);
42518 if (GC_DELREF(ref) == 0) {
42519 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
42520 efree_size(ref, sizeof(zend_reference));
42521 value = &tmp;
42522 } else {
42523 value = Z_REFVAL_P(value);
42524 Z_TRY_ADDREF_P(value);
42525 }
42526 } else {
42527 value = Z_REFVAL_P(value);
42528 Z_TRY_ADDREF_P(value);
42529 }
42530 } else if (IS_VAR == IS_CV) {
42531 Z_TRY_ADDREF_P(value);
42532 }
42533 }
42534 zend_hash_add_new(zobj->properties, name, value);
42535 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42536 ZVAL_COPY(EX_VAR(opline->result.var), value);
42537 }
42538 goto exit_assign_obj;
42539 }
42540 }
42541 }
42542 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42543 } else {
42544 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
42545 if (UNEXPECTED(!name)) {
42546 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42547 UNDEF_RESULT();
42548 goto exit_assign_obj;
42549 }
42550 }
42551
42552 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
42553 ZVAL_DEREF(value);
42554 }
42555
42556 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
42557
42558 if (IS_CONST != IS_CONST) {
42559 zend_tmp_string_release(tmp_name);
42560 }
42561
42562 free_and_exit_assign_obj:
42563 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
42564 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42565 }
42566 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42567 exit_assign_obj:
42568 if (garbage) {
42569 GC_DTOR_NO_REF(garbage);
42570 }
42571
42572
42573 /* assign_obj has two opcodes! */
42574 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42575 }
42576
42577 /* 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)42578 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42579 {
42580 USE_OPLINE
42581 zval *object, *value, tmp;
42582 zend_object *zobj;
42583 zend_string *name, *tmp_name;
42584 zend_refcounted *garbage = NULL;
42585
42586 SAVE_OPLINE();
42587 object = EX_VAR(opline->op1.var);
42588 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
42589
42590 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42591 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42592 object = Z_REFVAL_P(object);
42593 goto assign_object;
42594 }
42595 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
42596 value = &EG(uninitialized_zval);
42597 goto free_and_exit_assign_obj;
42598 }
42599
42600 assign_object:
42601 zobj = Z_OBJ_P(object);
42602 if (IS_CONST == IS_CONST) {
42603 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
42604 void **cache_slot = CACHE_ADDR(opline->extended_value);
42605 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42606 zval *property_val;
42607
42608 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42609 property_val = OBJ_PROP(zobj, prop_offset);
42610 if (Z_TYPE_P(property_val) != IS_UNDEF) {
42611 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
42612
42613 if (prop_info != NULL) {
42614 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
42615 goto free_and_exit_assign_obj;
42616 } else {
42617 fast_assign_obj:
42618 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
42619 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42620 ZVAL_COPY(EX_VAR(opline->result.var), value);
42621 }
42622 goto exit_assign_obj;
42623 }
42624 }
42625 } else {
42626 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42627 if (EXPECTED(zobj->properties != NULL)) {
42628 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
42629 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
42630 GC_DELREF(zobj->properties);
42631 }
42632 zobj->properties = zend_array_dup(zobj->properties);
42633 }
42634 property_val = zend_hash_find_known_hash(zobj->properties, name);
42635 if (property_val) {
42636 goto fast_assign_obj;
42637 }
42638 }
42639
42640 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
42641 if (EXPECTED(zobj->properties == NULL)) {
42642 rebuild_object_properties(zobj);
42643 }
42644 if (IS_CV == IS_CONST) {
42645 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
42646 Z_ADDREF_P(value);
42647 }
42648 } else if (IS_CV != IS_TMP_VAR) {
42649 if (Z_ISREF_P(value)) {
42650 if (IS_CV == IS_VAR) {
42651 zend_reference *ref = Z_REF_P(value);
42652 if (GC_DELREF(ref) == 0) {
42653 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
42654 efree_size(ref, sizeof(zend_reference));
42655 value = &tmp;
42656 } else {
42657 value = Z_REFVAL_P(value);
42658 Z_TRY_ADDREF_P(value);
42659 }
42660 } else {
42661 value = Z_REFVAL_P(value);
42662 Z_TRY_ADDREF_P(value);
42663 }
42664 } else if (IS_CV == IS_CV) {
42665 Z_TRY_ADDREF_P(value);
42666 }
42667 }
42668 zend_hash_add_new(zobj->properties, name, value);
42669 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42670 ZVAL_COPY(EX_VAR(opline->result.var), value);
42671 }
42672 goto exit_assign_obj;
42673 }
42674 }
42675 }
42676 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42677 } else {
42678 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
42679 if (UNEXPECTED(!name)) {
42680
42681 UNDEF_RESULT();
42682 goto exit_assign_obj;
42683 }
42684 }
42685
42686 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
42687 ZVAL_DEREF(value);
42688 }
42689
42690 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
42691
42692 if (IS_CONST != IS_CONST) {
42693 zend_tmp_string_release(tmp_name);
42694 }
42695
42696 free_and_exit_assign_obj:
42697 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
42698 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42699 }
42700
42701 exit_assign_obj:
42702 if (garbage) {
42703 GC_DTOR_NO_REF(garbage);
42704 }
42705
42706
42707 /* assign_obj has two opcodes! */
42708 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42709 }
42710
42711 /* 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)42712 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42713 {
42714 USE_OPLINE
42715 zval *object_ptr, *orig_object_ptr;
42716 zval *value;
42717 zval *variable_ptr;
42718 zval *dim;
42719 zend_refcounted *garbage = NULL;
42720
42721 SAVE_OPLINE();
42722 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
42723
42724 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
42725 try_assign_dim_array:
42726 SEPARATE_ARRAY(object_ptr);
42727 if (IS_CONST == IS_UNUSED) {
42728 value = RT_CONSTANT((opline+1), (opline+1)->op1);
42729 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
42730 HashTable *ht = Z_ARRVAL_P(object_ptr);
42731 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
42732 GC_ADDREF(ht);
42733 }
42734 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
42735 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
42736 zend_array_destroy(ht);
42737 goto assign_dim_error;
42738 }
42739 }
42740 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
42741 ZVAL_DEREF(value);
42742 }
42743 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
42744 if (UNEXPECTED(value == NULL)) {
42745 zend_cannot_add_element();
42746 goto assign_dim_error;
42747 } else if (IS_CONST == IS_CV) {
42748 if (Z_REFCOUNTED_P(value)) {
42749 Z_ADDREF_P(value);
42750 }
42751 } else if (IS_CONST == IS_VAR) {
42752 zval *free_op_data = EX_VAR((opline+1)->op1.var);
42753 if (Z_ISREF_P(free_op_data)) {
42754 if (Z_REFCOUNTED_P(value)) {
42755 Z_ADDREF_P(value);
42756 }
42757 zval_ptr_dtor_nogc(free_op_data);
42758 }
42759 } else if (IS_CONST == IS_CONST) {
42760 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
42761 Z_ADDREF_P(value);
42762 }
42763 }
42764 } else {
42765 dim = RT_CONSTANT(opline, opline->op2);
42766 if (IS_CONST == IS_CONST) {
42767 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
42768 } else {
42769 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
42770 }
42771 if (UNEXPECTED(variable_ptr == NULL)) {
42772 goto assign_dim_error;
42773 }
42774 value = RT_CONSTANT((opline+1), (opline+1)->op1);
42775 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
42776 }
42777 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42778 ZVAL_COPY(EX_VAR(opline->result.var), value);
42779 }
42780 if (garbage) {
42781 GC_DTOR_NO_REF(garbage);
42782 }
42783 } else {
42784 if (EXPECTED(Z_ISREF_P(object_ptr))) {
42785 object_ptr = Z_REFVAL_P(object_ptr);
42786 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
42787 goto try_assign_dim_array;
42788 }
42789 }
42790 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
42791 zend_object *obj = Z_OBJ_P(object_ptr);
42792
42793 GC_ADDREF(obj);
42794 dim = RT_CONSTANT(opline, opline->op2);
42795 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
42796 dim = ZVAL_UNDEFINED_OP2();
42797 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42798 dim++;
42799 }
42800
42801 value = RT_CONSTANT((opline+1), (opline+1)->op1);
42802 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
42803 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
42804 } else if (IS_CONST & (IS_CV|IS_VAR)) {
42805 ZVAL_DEREF(value);
42806 }
42807
42808 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
42809
42810 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
42811 zend_objects_store_del(obj);
42812 }
42813 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
42814 if (IS_CONST == IS_UNUSED) {
42815 zend_use_new_element_for_string();
42816
42817 UNDEF_RESULT();
42818 } else {
42819 dim = RT_CONSTANT(opline, opline->op2);
42820 value = RT_CONSTANT((opline+1), (opline+1)->op1);
42821 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
42822
42823 }
42824 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
42825 if (Z_ISREF_P(orig_object_ptr)
42826 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
42827 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
42828 dim = RT_CONSTANT(opline, opline->op2);
42829
42830 UNDEF_RESULT();
42831 } else {
42832 HashTable *ht = zend_new_array(8);
42833 uint8_t old_type = Z_TYPE_P(object_ptr);
42834
42835 ZVAL_ARR(object_ptr, ht);
42836 if (UNEXPECTED(old_type == IS_FALSE)) {
42837 GC_ADDREF(ht);
42838 zend_false_to_array_deprecated();
42839 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
42840 zend_array_destroy(ht);
42841 goto assign_dim_error;
42842 }
42843 }
42844 goto try_assign_dim_array;
42845 }
42846 } else {
42847 zend_use_scalar_as_array();
42848 dim = RT_CONSTANT(opline, opline->op2);
42849 assign_dim_error:
42850
42851 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42852 ZVAL_NULL(EX_VAR(opline->result.var));
42853 }
42854 }
42855 }
42856 if (IS_CONST != IS_UNUSED) {
42857
42858 }
42859
42860 /* assign_dim has two opcodes! */
42861 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42862 }
42863
ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42864 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42865 {
42866 USE_OPLINE
42867 zval *object_ptr, *orig_object_ptr;
42868 zval *value;
42869 zval *variable_ptr;
42870 zval *dim;
42871 zend_refcounted *garbage = NULL;
42872
42873 SAVE_OPLINE();
42874 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
42875
42876 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
42877 try_assign_dim_array:
42878 SEPARATE_ARRAY(object_ptr);
42879 if (IS_CONST == IS_UNUSED) {
42880 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
42881 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
42882 HashTable *ht = Z_ARRVAL_P(object_ptr);
42883 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
42884 GC_ADDREF(ht);
42885 }
42886 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
42887 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
42888 zend_array_destroy(ht);
42889 goto assign_dim_error;
42890 }
42891 }
42892 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
42893 ZVAL_DEREF(value);
42894 }
42895 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
42896 if (UNEXPECTED(value == NULL)) {
42897 zend_cannot_add_element();
42898 goto assign_dim_error;
42899 } else if (IS_TMP_VAR == IS_CV) {
42900 if (Z_REFCOUNTED_P(value)) {
42901 Z_ADDREF_P(value);
42902 }
42903 } else if (IS_TMP_VAR == IS_VAR) {
42904 zval *free_op_data = EX_VAR((opline+1)->op1.var);
42905 if (Z_ISREF_P(free_op_data)) {
42906 if (Z_REFCOUNTED_P(value)) {
42907 Z_ADDREF_P(value);
42908 }
42909 zval_ptr_dtor_nogc(free_op_data);
42910 }
42911 } else if (IS_TMP_VAR == IS_CONST) {
42912 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
42913 Z_ADDREF_P(value);
42914 }
42915 }
42916 } else {
42917 dim = RT_CONSTANT(opline, opline->op2);
42918 if (IS_CONST == IS_CONST) {
42919 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
42920 } else {
42921 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
42922 }
42923 if (UNEXPECTED(variable_ptr == NULL)) {
42924 goto assign_dim_error;
42925 }
42926 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
42927 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
42928 }
42929 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42930 ZVAL_COPY(EX_VAR(opline->result.var), value);
42931 }
42932 if (garbage) {
42933 GC_DTOR_NO_REF(garbage);
42934 }
42935 } else {
42936 if (EXPECTED(Z_ISREF_P(object_ptr))) {
42937 object_ptr = Z_REFVAL_P(object_ptr);
42938 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
42939 goto try_assign_dim_array;
42940 }
42941 }
42942 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
42943 zend_object *obj = Z_OBJ_P(object_ptr);
42944
42945 GC_ADDREF(obj);
42946 dim = RT_CONSTANT(opline, opline->op2);
42947 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
42948 dim = ZVAL_UNDEFINED_OP2();
42949 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42950 dim++;
42951 }
42952
42953 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
42954 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
42955 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
42956 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
42957 ZVAL_DEREF(value);
42958 }
42959
42960 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
42961
42962 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42963 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
42964 zend_objects_store_del(obj);
42965 }
42966 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
42967 if (IS_CONST == IS_UNUSED) {
42968 zend_use_new_element_for_string();
42969 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42970 UNDEF_RESULT();
42971 } else {
42972 dim = RT_CONSTANT(opline, opline->op2);
42973 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
42974 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
42975 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42976 }
42977 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
42978 if (Z_ISREF_P(orig_object_ptr)
42979 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
42980 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
42981 dim = RT_CONSTANT(opline, opline->op2);
42982 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42983 UNDEF_RESULT();
42984 } else {
42985 HashTable *ht = zend_new_array(8);
42986 uint8_t old_type = Z_TYPE_P(object_ptr);
42987
42988 ZVAL_ARR(object_ptr, ht);
42989 if (UNEXPECTED(old_type == IS_FALSE)) {
42990 GC_ADDREF(ht);
42991 zend_false_to_array_deprecated();
42992 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
42993 zend_array_destroy(ht);
42994 goto assign_dim_error;
42995 }
42996 }
42997 goto try_assign_dim_array;
42998 }
42999 } else {
43000 zend_use_scalar_as_array();
43001 dim = RT_CONSTANT(opline, opline->op2);
43002 assign_dim_error:
43003 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43004 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43005 ZVAL_NULL(EX_VAR(opline->result.var));
43006 }
43007 }
43008 }
43009 if (IS_CONST != IS_UNUSED) {
43010
43011 }
43012
43013 /* assign_dim has two opcodes! */
43014 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43015 }
43016
ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43017 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43018 {
43019 USE_OPLINE
43020 zval *object_ptr, *orig_object_ptr;
43021 zval *value;
43022 zval *variable_ptr;
43023 zval *dim;
43024 zend_refcounted *garbage = NULL;
43025
43026 SAVE_OPLINE();
43027 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
43028
43029 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43030 try_assign_dim_array:
43031 SEPARATE_ARRAY(object_ptr);
43032 if (IS_CONST == IS_UNUSED) {
43033 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43034 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
43035 HashTable *ht = Z_ARRVAL_P(object_ptr);
43036 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
43037 GC_ADDREF(ht);
43038 }
43039 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43040 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
43041 zend_array_destroy(ht);
43042 goto assign_dim_error;
43043 }
43044 }
43045 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
43046 ZVAL_DEREF(value);
43047 }
43048 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
43049 if (UNEXPECTED(value == NULL)) {
43050 zend_cannot_add_element();
43051 goto assign_dim_error;
43052 } else if (IS_VAR == IS_CV) {
43053 if (Z_REFCOUNTED_P(value)) {
43054 Z_ADDREF_P(value);
43055 }
43056 } else if (IS_VAR == IS_VAR) {
43057 zval *free_op_data = EX_VAR((opline+1)->op1.var);
43058 if (Z_ISREF_P(free_op_data)) {
43059 if (Z_REFCOUNTED_P(value)) {
43060 Z_ADDREF_P(value);
43061 }
43062 zval_ptr_dtor_nogc(free_op_data);
43063 }
43064 } else if (IS_VAR == IS_CONST) {
43065 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
43066 Z_ADDREF_P(value);
43067 }
43068 }
43069 } else {
43070 dim = RT_CONSTANT(opline, opline->op2);
43071 if (IS_CONST == IS_CONST) {
43072 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
43073 } else {
43074 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
43075 }
43076 if (UNEXPECTED(variable_ptr == NULL)) {
43077 goto assign_dim_error;
43078 }
43079 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43080 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
43081 }
43082 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43083 ZVAL_COPY(EX_VAR(opline->result.var), value);
43084 }
43085 if (garbage) {
43086 GC_DTOR_NO_REF(garbage);
43087 }
43088 } else {
43089 if (EXPECTED(Z_ISREF_P(object_ptr))) {
43090 object_ptr = Z_REFVAL_P(object_ptr);
43091 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43092 goto try_assign_dim_array;
43093 }
43094 }
43095 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
43096 zend_object *obj = Z_OBJ_P(object_ptr);
43097
43098 GC_ADDREF(obj);
43099 dim = RT_CONSTANT(opline, opline->op2);
43100 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
43101 dim = ZVAL_UNDEFINED_OP2();
43102 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
43103 dim++;
43104 }
43105
43106 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43107 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
43108 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43109 } else if (IS_VAR & (IS_CV|IS_VAR)) {
43110 ZVAL_DEREF(value);
43111 }
43112
43113 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
43114
43115 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43116 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
43117 zend_objects_store_del(obj);
43118 }
43119 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
43120 if (IS_CONST == IS_UNUSED) {
43121 zend_use_new_element_for_string();
43122 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43123 UNDEF_RESULT();
43124 } else {
43125 dim = RT_CONSTANT(opline, opline->op2);
43126 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43127 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
43128 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43129 }
43130 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
43131 if (Z_ISREF_P(orig_object_ptr)
43132 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
43133 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
43134 dim = RT_CONSTANT(opline, opline->op2);
43135 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43136 UNDEF_RESULT();
43137 } else {
43138 HashTable *ht = zend_new_array(8);
43139 uint8_t old_type = Z_TYPE_P(object_ptr);
43140
43141 ZVAL_ARR(object_ptr, ht);
43142 if (UNEXPECTED(old_type == IS_FALSE)) {
43143 GC_ADDREF(ht);
43144 zend_false_to_array_deprecated();
43145 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
43146 zend_array_destroy(ht);
43147 goto assign_dim_error;
43148 }
43149 }
43150 goto try_assign_dim_array;
43151 }
43152 } else {
43153 zend_use_scalar_as_array();
43154 dim = RT_CONSTANT(opline, opline->op2);
43155 assign_dim_error:
43156 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43157 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43158 ZVAL_NULL(EX_VAR(opline->result.var));
43159 }
43160 }
43161 }
43162 if (IS_CONST != IS_UNUSED) {
43163
43164 }
43165
43166 /* assign_dim has two opcodes! */
43167 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43168 }
43169
ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43170 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43171 {
43172 USE_OPLINE
43173 zval *object_ptr, *orig_object_ptr;
43174 zval *value;
43175 zval *variable_ptr;
43176 zval *dim;
43177 zend_refcounted *garbage = NULL;
43178
43179 SAVE_OPLINE();
43180 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
43181
43182 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43183 try_assign_dim_array:
43184 SEPARATE_ARRAY(object_ptr);
43185 if (IS_CONST == IS_UNUSED) {
43186 value = EX_VAR((opline+1)->op1.var);
43187 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
43188 HashTable *ht = Z_ARRVAL_P(object_ptr);
43189 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
43190 GC_ADDREF(ht);
43191 }
43192 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43193 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
43194 zend_array_destroy(ht);
43195 goto assign_dim_error;
43196 }
43197 }
43198 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
43199 ZVAL_DEREF(value);
43200 }
43201 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
43202 if (UNEXPECTED(value == NULL)) {
43203 zend_cannot_add_element();
43204 goto assign_dim_error;
43205 } else if (IS_CV == IS_CV) {
43206 if (Z_REFCOUNTED_P(value)) {
43207 Z_ADDREF_P(value);
43208 }
43209 } else if (IS_CV == IS_VAR) {
43210 zval *free_op_data = EX_VAR((opline+1)->op1.var);
43211 if (Z_ISREF_P(free_op_data)) {
43212 if (Z_REFCOUNTED_P(value)) {
43213 Z_ADDREF_P(value);
43214 }
43215 zval_ptr_dtor_nogc(free_op_data);
43216 }
43217 } else if (IS_CV == IS_CONST) {
43218 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
43219 Z_ADDREF_P(value);
43220 }
43221 }
43222 } else {
43223 dim = RT_CONSTANT(opline, opline->op2);
43224 if (IS_CONST == IS_CONST) {
43225 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
43226 } else {
43227 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
43228 }
43229 if (UNEXPECTED(variable_ptr == NULL)) {
43230 goto assign_dim_error;
43231 }
43232 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
43233 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
43234 }
43235 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43236 ZVAL_COPY(EX_VAR(opline->result.var), value);
43237 }
43238 if (garbage) {
43239 GC_DTOR_NO_REF(garbage);
43240 }
43241 } else {
43242 if (EXPECTED(Z_ISREF_P(object_ptr))) {
43243 object_ptr = Z_REFVAL_P(object_ptr);
43244 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43245 goto try_assign_dim_array;
43246 }
43247 }
43248 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
43249 zend_object *obj = Z_OBJ_P(object_ptr);
43250
43251 GC_ADDREF(obj);
43252 dim = RT_CONSTANT(opline, opline->op2);
43253 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
43254 dim = ZVAL_UNDEFINED_OP2();
43255 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
43256 dim++;
43257 }
43258
43259 value = EX_VAR((opline+1)->op1.var);
43260 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
43261 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43262 } else if (IS_CV & (IS_CV|IS_VAR)) {
43263 ZVAL_DEREF(value);
43264 }
43265
43266 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
43267
43268 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
43269 zend_objects_store_del(obj);
43270 }
43271 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
43272 if (IS_CONST == IS_UNUSED) {
43273 zend_use_new_element_for_string();
43274
43275 UNDEF_RESULT();
43276 } else {
43277 dim = RT_CONSTANT(opline, opline->op2);
43278 value = EX_VAR((opline+1)->op1.var);
43279 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
43280
43281 }
43282 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
43283 if (Z_ISREF_P(orig_object_ptr)
43284 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
43285 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
43286 dim = RT_CONSTANT(opline, opline->op2);
43287
43288 UNDEF_RESULT();
43289 } else {
43290 HashTable *ht = zend_new_array(8);
43291 uint8_t old_type = Z_TYPE_P(object_ptr);
43292
43293 ZVAL_ARR(object_ptr, ht);
43294 if (UNEXPECTED(old_type == IS_FALSE)) {
43295 GC_ADDREF(ht);
43296 zend_false_to_array_deprecated();
43297 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
43298 zend_array_destroy(ht);
43299 goto assign_dim_error;
43300 }
43301 }
43302 goto try_assign_dim_array;
43303 }
43304 } else {
43305 zend_use_scalar_as_array();
43306 dim = RT_CONSTANT(opline, opline->op2);
43307 assign_dim_error:
43308
43309 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43310 ZVAL_NULL(EX_VAR(opline->result.var));
43311 }
43312 }
43313 }
43314 if (IS_CONST != IS_UNUSED) {
43315
43316 }
43317
43318 /* assign_dim has two opcodes! */
43319 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43320 }
43321
ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43322 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43323 {
43324 USE_OPLINE
43325 zval *value;
43326 zval *variable_ptr;
43327
43328 SAVE_OPLINE();
43329 value = RT_CONSTANT(opline, opline->op2);
43330 variable_ptr = EX_VAR(opline->op1.var);
43331
43332 if (0 || UNEXPECTED(0)) {
43333 zend_refcounted *garbage = NULL;
43334
43335 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
43336 if (UNEXPECTED(0)) {
43337 ZVAL_COPY(EX_VAR(opline->result.var), value);
43338 }
43339 if (garbage) {
43340 GC_DTOR_NO_REF(garbage);
43341 }
43342 } else {
43343 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
43344 }
43345
43346 /* zend_assign_to_variable() always takes care of op2, never free it! */
43347
43348 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43349 }
43350
ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43351 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43352 {
43353 USE_OPLINE
43354 zval *value;
43355 zval *variable_ptr;
43356
43357 SAVE_OPLINE();
43358 value = RT_CONSTANT(opline, opline->op2);
43359 variable_ptr = EX_VAR(opline->op1.var);
43360
43361 if (0 || UNEXPECTED(1)) {
43362 zend_refcounted *garbage = NULL;
43363
43364 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
43365 if (UNEXPECTED(1)) {
43366 ZVAL_COPY(EX_VAR(opline->result.var), value);
43367 }
43368 if (garbage) {
43369 GC_DTOR_NO_REF(garbage);
43370 }
43371 } else {
43372 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
43373 }
43374
43375 /* zend_assign_to_variable() always takes care of op2, never free it! */
43376
43377 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43378 }
43379
ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43380 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43381 {
43382 USE_OPLINE
43383 zval *property, *container, *value_ptr;
43384
43385 SAVE_OPLINE();
43386
43387 container = EX_VAR(opline->op1.var);
43388 property = RT_CONSTANT(opline, opline->op2);
43389
43390 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43391
43392 if (1) {
43393 if (IS_CV == IS_UNUSED) {
43394 if (IS_CONST == IS_CONST) {
43395 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43396 } else {
43397 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43398 }
43399 } else {
43400 if (IS_CONST == IS_CONST) {
43401 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43402 } else {
43403 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43404 }
43405 }
43406 } else {
43407 zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43408 }
43409
43410
43411 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43412 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43413 }
43414
43415 /* 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)43416 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43417 {
43418 USE_OPLINE
43419 zval *property, *container, *value_ptr;
43420
43421 SAVE_OPLINE();
43422
43423 container = EX_VAR(opline->op1.var);
43424 property = RT_CONSTANT(opline, opline->op2);
43425
43426 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
43427
43428 if (1) {
43429 if (IS_CV == IS_UNUSED) {
43430 if (IS_CONST == IS_CONST) {
43431 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43432 } else {
43433 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43434 }
43435 } else {
43436 if (IS_CONST == IS_CONST) {
43437 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43438 } else {
43439 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43440 }
43441 }
43442 } else {
43443 zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43444 }
43445
43446
43447
43448 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43449 }
43450
43451 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43452 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43453 {
43454 USE_OPLINE
43455 zval *op1, *op2;
43456 zend_string *op1_str, *op2_str, *str;
43457
43458
43459 op1 = EX_VAR(opline->op1.var);
43460 op2 = RT_CONSTANT(opline, opline->op2);
43461 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
43462 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
43463 zend_string *op1_str = Z_STR_P(op1);
43464 zend_string *op2_str = Z_STR_P(op2);
43465 zend_string *str;
43466 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
43467
43468 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
43469 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
43470 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
43471 } else {
43472 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
43473 }
43474 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
43475 zend_string_release_ex(op1_str, 0);
43476 }
43477 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
43478 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
43479 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
43480 } else {
43481 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
43482 }
43483 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
43484 zend_string_release_ex(op2_str, 0);
43485 }
43486 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
43487 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
43488 size_t len = ZSTR_LEN(op1_str);
43489
43490 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
43491 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
43492 GC_ADD_FLAGS(str, flags);
43493 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
43494 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
43495 zend_string_release_ex(op2_str, 0);
43496 }
43497 } else {
43498 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
43499 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
43500 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
43501 GC_ADD_FLAGS(str, flags);
43502 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
43503 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
43504 zend_string_release_ex(op1_str, 0);
43505 }
43506 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
43507 zend_string_release_ex(op2_str, 0);
43508 }
43509 }
43510 ZEND_VM_NEXT_OPCODE();
43511 }
43512
43513 SAVE_OPLINE();
43514 if (IS_CV == IS_CONST) {
43515 op1_str = Z_STR_P(op1);
43516 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
43517 op1_str = zend_string_copy(Z_STR_P(op1));
43518 } else {
43519 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
43520 ZVAL_UNDEFINED_OP1();
43521 }
43522 op1_str = zval_get_string_func(op1);
43523 }
43524 if (IS_CONST == IS_CONST) {
43525 op2_str = Z_STR_P(op2);
43526 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
43527 op2_str = zend_string_copy(Z_STR_P(op2));
43528 } else {
43529 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
43530 ZVAL_UNDEFINED_OP2();
43531 }
43532 op2_str = zval_get_string_func(op2);
43533 }
43534 do {
43535 if (IS_CV != IS_CONST) {
43536 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
43537 if (IS_CONST == IS_CONST) {
43538 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
43539 GC_ADDREF(op2_str);
43540 }
43541 }
43542 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
43543 zend_string_release_ex(op1_str, 0);
43544 break;
43545 }
43546 }
43547 if (IS_CONST != IS_CONST) {
43548 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
43549 if (IS_CV == IS_CONST) {
43550 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
43551 GC_ADDREF(op1_str);
43552 }
43553 }
43554 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
43555 zend_string_release_ex(op2_str, 0);
43556 break;
43557 }
43558 }
43559 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
43560 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
43561 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
43562
43563 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
43564 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
43565 if (IS_CV != IS_CONST) {
43566 zend_string_release_ex(op1_str, 0);
43567 }
43568 if (IS_CONST != IS_CONST) {
43569 zend_string_release_ex(op2_str, 0);
43570 }
43571 } while (0);
43572
43573
43574 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43575 }
43576
ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43577 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43578 {
43579 USE_OPLINE
43580 zval *function_name;
43581 zval *object;
43582 zend_function *fbc;
43583 zend_class_entry *called_scope;
43584 zend_object *obj;
43585 zend_execute_data *call;
43586 uint32_t call_info;
43587
43588 SAVE_OPLINE();
43589
43590 object = EX_VAR(opline->op1.var);
43591
43592 if (IS_CONST != IS_CONST) {
43593 function_name = RT_CONSTANT(opline, opline->op2);
43594 }
43595
43596 if (IS_CONST != IS_CONST &&
43597 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
43598 do {
43599 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
43600 function_name = Z_REFVAL_P(function_name);
43601 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
43602 break;
43603 }
43604 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
43605 ZVAL_UNDEFINED_OP2();
43606 if (UNEXPECTED(EG(exception) != NULL)) {
43607
43608 HANDLE_EXCEPTION();
43609 }
43610 }
43611 zend_throw_error(NULL, "Method name must be a string");
43612
43613
43614 HANDLE_EXCEPTION();
43615 } while (0);
43616 }
43617
43618 if (IS_CV == IS_UNUSED) {
43619 obj = Z_OBJ_P(object);
43620 } else {
43621 do {
43622 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
43623 obj = Z_OBJ_P(object);
43624 } else {
43625 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
43626 zend_reference *ref = Z_REF_P(object);
43627
43628 object = &ref->val;
43629 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
43630 obj = Z_OBJ_P(object);
43631 if (IS_CV & IS_VAR) {
43632 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
43633 efree_size(ref, sizeof(zend_reference));
43634 } else {
43635 Z_ADDREF_P(object);
43636 }
43637 }
43638 break;
43639 }
43640 }
43641 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
43642 object = ZVAL_UNDEFINED_OP1();
43643 if (UNEXPECTED(EG(exception) != NULL)) {
43644 if (IS_CONST != IS_CONST) {
43645
43646 }
43647 HANDLE_EXCEPTION();
43648 }
43649 }
43650 if (IS_CONST == IS_CONST) {
43651 function_name = RT_CONSTANT(opline, opline->op2);
43652 }
43653 zend_invalid_method_call(object, function_name);
43654
43655
43656 HANDLE_EXCEPTION();
43657 }
43658 } while (0);
43659 }
43660
43661 called_scope = obj->ce;
43662
43663 if (IS_CONST == IS_CONST &&
43664 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
43665 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
43666 } else {
43667 zend_object *orig_obj = obj;
43668
43669 if (IS_CONST == IS_CONST) {
43670 function_name = RT_CONSTANT(opline, opline->op2);
43671 }
43672
43673 /* First, locate the function. */
43674 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
43675 if (UNEXPECTED(fbc == NULL)) {
43676 if (EXPECTED(!EG(exception))) {
43677 zend_undefined_method(obj->ce, Z_STR_P(function_name));
43678 }
43679
43680 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
43681 zend_objects_store_del(orig_obj);
43682 }
43683 HANDLE_EXCEPTION();
43684 }
43685 if (IS_CONST == IS_CONST &&
43686 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
43687 EXPECTED(obj == orig_obj)) {
43688 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
43689 }
43690 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
43691 GC_ADDREF(obj); /* For $this pointer */
43692 if (GC_DELREF(orig_obj) == 0) {
43693 zend_objects_store_del(orig_obj);
43694 }
43695 }
43696 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
43697 init_func_run_time_cache(&fbc->op_array);
43698 }
43699 }
43700
43701 if (IS_CONST != IS_CONST) {
43702
43703 }
43704
43705 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
43706 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
43707 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
43708 zend_objects_store_del(obj);
43709 if (UNEXPECTED(EG(exception))) {
43710 HANDLE_EXCEPTION();
43711 }
43712 }
43713 /* call static method */
43714 obj = (zend_object*)called_scope;
43715 call_info = ZEND_CALL_NESTED_FUNCTION;
43716 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
43717 if (IS_CV == IS_CV) {
43718 GC_ADDREF(obj); /* For $this pointer */
43719 }
43720 /* CV may be changed indirectly (e.g. when it's a reference) */
43721 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
43722 }
43723
43724 call = zend_vm_stack_push_call_frame(call_info,
43725 fbc, opline->extended_value, obj);
43726 call->prev_execute_data = EX(call);
43727 EX(call) = call;
43728
43729 ZEND_VM_NEXT_OPCODE();
43730 }
43731
ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43732 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43733 {
43734 USE_OPLINE
43735 zval *varptr, *arg;
43736
43737 if (IS_CONST == IS_CONST) {
43738 SAVE_OPLINE();
43739 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43740 uint32_t arg_num;
43741 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
43742 if (UNEXPECTED(!arg)) {
43743
43744 HANDLE_EXCEPTION();
43745 }
43746 } else {
43747 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
43748 }
43749
43750 varptr = EX_VAR(opline->op1.var);
43751 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
43752 SAVE_OPLINE();
43753 ZVAL_UNDEFINED_OP1();
43754 ZVAL_NULL(arg);
43755 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43756 }
43757
43758 if (IS_CV == IS_CV) {
43759 ZVAL_COPY_DEREF(arg, varptr);
43760 } else /* if (IS_CV == IS_VAR) */ {
43761 if (UNEXPECTED(Z_ISREF_P(varptr))) {
43762 zend_refcounted *ref = Z_COUNTED_P(varptr);
43763
43764 varptr = Z_REFVAL_P(varptr);
43765 ZVAL_COPY_VALUE(arg, varptr);
43766 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
43767 efree_size(ref, sizeof(zend_reference));
43768 } else if (Z_OPT_REFCOUNTED_P(arg)) {
43769 Z_ADDREF_P(arg);
43770 }
43771 } else {
43772 ZVAL_COPY_VALUE(arg, varptr);
43773 }
43774 }
43775
43776 ZEND_VM_NEXT_OPCODE();
43777 }
43778
ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43779 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43780 {
43781 USE_OPLINE
43782 zval *varptr, *arg;
43783
43784 SAVE_OPLINE();
43785 if (IS_CONST == IS_CONST) {
43786 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43787 uint32_t arg_num;
43788 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
43789 if (UNEXPECTED(!arg)) {
43790
43791 HANDLE_EXCEPTION();
43792 }
43793 } else {
43794 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
43795 }
43796
43797 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
43798 if (Z_ISREF_P(varptr)) {
43799 Z_ADDREF_P(varptr);
43800 } else {
43801 ZVAL_MAKE_REF_EX(varptr, 2);
43802 }
43803 ZVAL_REF(arg, Z_REF_P(varptr));
43804
43805 ZEND_VM_NEXT_OPCODE();
43806 }
43807
ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43808 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43809 {
43810 USE_OPLINE
43811 zval *varptr, *arg;
43812 uint32_t arg_num;
43813
43814 if (IS_CONST == IS_CONST) {
43815 SAVE_OPLINE();
43816 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43817 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
43818 if (UNEXPECTED(!arg)) {
43819
43820 HANDLE_EXCEPTION();
43821 }
43822 } else {
43823 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
43824 arg_num = opline->op2.num;
43825 }
43826
43827 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
43828 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
43829 goto send_var_by_ref;
43830 }
43831 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
43832 send_var_by_ref:
43833 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
43834 if (Z_ISREF_P(varptr)) {
43835 Z_ADDREF_P(varptr);
43836 } else {
43837 ZVAL_MAKE_REF_EX(varptr, 2);
43838 }
43839 ZVAL_REF(arg, Z_REF_P(varptr));
43840
43841 ZEND_VM_NEXT_OPCODE();
43842 }
43843
43844 varptr = EX_VAR(opline->op1.var);
43845 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
43846 SAVE_OPLINE();
43847 ZVAL_UNDEFINED_OP1();
43848 ZVAL_NULL(arg);
43849 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43850 }
43851
43852 if (IS_CV == IS_CV) {
43853 ZVAL_COPY_DEREF(arg, varptr);
43854 } else /* if (IS_CV == IS_VAR) */ {
43855 if (UNEXPECTED(Z_ISREF_P(varptr))) {
43856 zend_refcounted *ref = Z_COUNTED_P(varptr);
43857
43858 varptr = Z_REFVAL_P(varptr);
43859 ZVAL_COPY_VALUE(arg, varptr);
43860 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
43861 efree_size(ref, sizeof(zend_reference));
43862 } else if (Z_OPT_REFCOUNTED_P(arg)) {
43863 Z_ADDREF_P(arg);
43864 }
43865 } else {
43866 ZVAL_COPY_VALUE(arg, varptr);
43867 }
43868 }
43869
43870 ZEND_VM_NEXT_OPCODE();
43871 }
43872
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43873 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43874 {
43875 USE_OPLINE
43876 zval *expr_ptr, new_expr;
43877
43878 SAVE_OPLINE();
43879 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
43880 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
43881 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
43882 if (Z_ISREF_P(expr_ptr)) {
43883 Z_ADDREF_P(expr_ptr);
43884 } else {
43885 ZVAL_MAKE_REF_EX(expr_ptr, 2);
43886 }
43887
43888 } else {
43889 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
43890 if (IS_CV == IS_TMP_VAR) {
43891 /* pass */
43892 } else if (IS_CV == IS_CONST) {
43893 Z_TRY_ADDREF_P(expr_ptr);
43894 } else if (IS_CV == IS_CV) {
43895 ZVAL_DEREF(expr_ptr);
43896 Z_TRY_ADDREF_P(expr_ptr);
43897 } else /* if (IS_CV == IS_VAR) */ {
43898 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
43899 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
43900
43901 expr_ptr = Z_REFVAL_P(expr_ptr);
43902 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
43903 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
43904 expr_ptr = &new_expr;
43905 efree_size(ref, sizeof(zend_reference));
43906 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
43907 Z_ADDREF_P(expr_ptr);
43908 }
43909 }
43910 }
43911 }
43912
43913 if (IS_CONST != IS_UNUSED) {
43914 zval *offset = RT_CONSTANT(opline, opline->op2);
43915 zend_string *str;
43916 zend_ulong hval;
43917
43918 add_again:
43919 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
43920 str = Z_STR_P(offset);
43921 if (IS_CONST != IS_CONST) {
43922 if (ZEND_HANDLE_NUMERIC(str, hval)) {
43923 goto num_index;
43924 }
43925 }
43926 str_index:
43927 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
43928 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
43929 hval = Z_LVAL_P(offset);
43930 num_index:
43931 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
43932 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
43933 offset = Z_REFVAL_P(offset);
43934 goto add_again;
43935 } else if (Z_TYPE_P(offset) == IS_NULL) {
43936 str = ZSTR_EMPTY_ALLOC();
43937 goto str_index;
43938 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
43939 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
43940 goto num_index;
43941 } else if (Z_TYPE_P(offset) == IS_FALSE) {
43942 hval = 0;
43943 goto num_index;
43944 } else if (Z_TYPE_P(offset) == IS_TRUE) {
43945 hval = 1;
43946 goto num_index;
43947 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
43948 zend_use_resource_as_offset(offset);
43949 hval = Z_RES_HANDLE_P(offset);
43950 goto num_index;
43951 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
43952 ZVAL_UNDEFINED_OP2();
43953 str = ZSTR_EMPTY_ALLOC();
43954 goto str_index;
43955 } else {
43956 zend_illegal_array_offset_access(offset);
43957 zval_ptr_dtor_nogc(expr_ptr);
43958 }
43959
43960 } else {
43961 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
43962 zend_cannot_add_element();
43963 zval_ptr_dtor_nogc(expr_ptr);
43964 }
43965 }
43966 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43967 }
43968
ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43969 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43970 {
43971 zval *array;
43972 uint32_t size;
43973 USE_OPLINE
43974
43975 array = EX_VAR(opline->result.var);
43976 if (IS_CV != IS_UNUSED) {
43977 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
43978 ZVAL_ARR(array, zend_new_array(size));
43979 /* Explicitly initialize array as not-packed if flag is set */
43980 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
43981 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
43982 }
43983 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43984 } else {
43985 ZVAL_ARR(array, zend_new_array(0));
43986 ZEND_VM_NEXT_OPCODE();
43987 }
43988 }
43989
ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43990 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43991 {
43992 USE_OPLINE
43993 zval *container;
43994 zval *offset;
43995 zend_ulong hval;
43996 zend_string *key;
43997
43998 SAVE_OPLINE();
43999 container = EX_VAR(opline->op1.var);
44000 offset = RT_CONSTANT(opline, opline->op2);
44001
44002 do {
44003 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44004 HashTable *ht;
44005
44006 unset_dim_array:
44007 SEPARATE_ARRAY(container);
44008 ht = Z_ARRVAL_P(container);
44009 offset_again:
44010 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
44011 key = Z_STR_P(offset);
44012 if (IS_CONST != IS_CONST) {
44013 if (ZEND_HANDLE_NUMERIC(key, hval)) {
44014 goto num_index_dim;
44015 }
44016 }
44017 str_index_dim:
44018 ZEND_ASSERT(ht != &EG(symbol_table));
44019 zend_hash_del(ht, key);
44020 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
44021 hval = Z_LVAL_P(offset);
44022 num_index_dim:
44023 zend_hash_index_del(ht, hval);
44024 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
44025 offset = Z_REFVAL_P(offset);
44026 goto offset_again;
44027 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
44028 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
44029 goto num_index_dim;
44030 } else if (Z_TYPE_P(offset) == IS_NULL) {
44031 key = ZSTR_EMPTY_ALLOC();
44032 goto str_index_dim;
44033 } else if (Z_TYPE_P(offset) == IS_FALSE) {
44034 hval = 0;
44035 goto num_index_dim;
44036 } else if (Z_TYPE_P(offset) == IS_TRUE) {
44037 hval = 1;
44038 goto num_index_dim;
44039 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
44040 zend_use_resource_as_offset(offset);
44041 hval = Z_RES_HANDLE_P(offset);
44042 goto num_index_dim;
44043 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
44044 ZVAL_UNDEFINED_OP2();
44045 key = ZSTR_EMPTY_ALLOC();
44046 goto str_index_dim;
44047 } else {
44048 zend_illegal_array_offset_unset(offset);
44049 }
44050 break;
44051 } else if (Z_ISREF_P(container)) {
44052 container = Z_REFVAL_P(container);
44053 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44054 goto unset_dim_array;
44055 }
44056 }
44057 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
44058 container = ZVAL_UNDEFINED_OP1();
44059 }
44060 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
44061 offset = ZVAL_UNDEFINED_OP2();
44062 }
44063 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
44064 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
44065 offset++;
44066 }
44067 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
44068 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
44069 zend_throw_error(NULL, "Cannot unset string offsets");
44070 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
44071 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
44072 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
44073 zend_false_to_array_deprecated();
44074 }
44075 } while (0);
44076
44077
44078 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44079 }
44080
ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44081 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44082 {
44083 USE_OPLINE
44084 zval *container;
44085 zval *offset;
44086 zend_string *name, *tmp_name;
44087
44088 SAVE_OPLINE();
44089 container = EX_VAR(opline->op1.var);
44090 offset = RT_CONSTANT(opline, opline->op2);
44091
44092 do {
44093 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
44094 if (Z_ISREF_P(container)) {
44095 container = Z_REFVAL_P(container);
44096 if (Z_TYPE_P(container) != IS_OBJECT) {
44097 if (IS_CV == IS_CV
44098 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
44099 ZVAL_UNDEFINED_OP1();
44100 }
44101 break;
44102 }
44103 } else {
44104 break;
44105 }
44106 }
44107 if (IS_CONST == IS_CONST) {
44108 name = Z_STR_P(offset);
44109 } else {
44110 name = zval_try_get_tmp_string(offset, &tmp_name);
44111 if (UNEXPECTED(!name)) {
44112 break;
44113 }
44114 }
44115 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
44116 if (IS_CONST != IS_CONST) {
44117 zend_tmp_string_release(tmp_name);
44118 }
44119 } while (0);
44120
44121
44122 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44123 }
44124
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44125 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44126 {
44127 USE_OPLINE
44128 zval *container;
44129 bool result;
44130 zend_ulong hval;
44131 zval *offset;
44132
44133 SAVE_OPLINE();
44134 container = EX_VAR(opline->op1.var);
44135 offset = RT_CONSTANT(opline, opline->op2);
44136
44137 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44138 HashTable *ht;
44139 zval *value;
44140 zend_string *str;
44141
44142 isset_dim_obj_array:
44143 ht = Z_ARRVAL_P(container);
44144 isset_again:
44145 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
44146 str = Z_STR_P(offset);
44147 if (IS_CONST != IS_CONST) {
44148 if (ZEND_HANDLE_NUMERIC(str, hval)) {
44149 goto num_index_prop;
44150 }
44151 }
44152 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
44153 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
44154 hval = Z_LVAL_P(offset);
44155 num_index_prop:
44156 value = zend_hash_index_find(ht, hval);
44157 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
44158 offset = Z_REFVAL_P(offset);
44159 goto isset_again;
44160 } else {
44161 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
44162 if (UNEXPECTED(EG(exception))) {
44163 result = 0;
44164 goto isset_dim_obj_exit;
44165 }
44166 }
44167
44168 if (!(opline->extended_value & ZEND_ISEMPTY)) {
44169 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
44170 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
44171 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
44172
44173 if (IS_CV & (IS_CONST|IS_CV)) {
44174 /* avoid exception check */
44175
44176 ZEND_VM_SMART_BRANCH(result, 0);
44177 }
44178 } else {
44179 result = (value == NULL || !i_zend_is_true(value));
44180 }
44181 goto isset_dim_obj_exit;
44182 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
44183 container = Z_REFVAL_P(container);
44184 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44185 goto isset_dim_obj_array;
44186 }
44187 }
44188
44189 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
44190 offset++;
44191 }
44192 if (!(opline->extended_value & ZEND_ISEMPTY)) {
44193 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
44194 } else {
44195 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
44196 }
44197
44198 isset_dim_obj_exit:
44199
44200
44201 ZEND_VM_SMART_BRANCH(result, 1);
44202 }
44203
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44204 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44205 {
44206 USE_OPLINE
44207 zval *container;
44208 int result;
44209 zval *offset;
44210 zend_string *name, *tmp_name;
44211
44212 SAVE_OPLINE();
44213 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
44214 offset = RT_CONSTANT(opline, opline->op2);
44215
44216 if (IS_CV == IS_CONST ||
44217 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
44218 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
44219 container = Z_REFVAL_P(container);
44220 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
44221 result = (opline->extended_value & ZEND_ISEMPTY);
44222 goto isset_object_finish;
44223 }
44224 } else {
44225 result = (opline->extended_value & ZEND_ISEMPTY);
44226 goto isset_object_finish;
44227 }
44228 }
44229
44230 if (IS_CONST == IS_CONST) {
44231 name = Z_STR_P(offset);
44232 } else {
44233 name = zval_try_get_tmp_string(offset, &tmp_name);
44234 if (UNEXPECTED(!name)) {
44235 result = 0;
44236 goto isset_object_finish;
44237 }
44238 }
44239
44240 result =
44241 (opline->extended_value & ZEND_ISEMPTY) ^
44242 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));
44243
44244 if (IS_CONST != IS_CONST) {
44245 zend_tmp_string_release(tmp_name);
44246 }
44247
44248 isset_object_finish:
44249
44250
44251 ZEND_VM_SMART_BRANCH(result, 1);
44252 }
44253
ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44254 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44255 {
44256 USE_OPLINE
44257
44258 zval *key, *subject;
44259 HashTable *ht;
44260 bool result;
44261
44262 SAVE_OPLINE();
44263
44264 key = EX_VAR(opline->op1.var);
44265 subject = RT_CONSTANT(opline, opline->op2);
44266
44267 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
44268 array_key_exists_array:
44269 ht = Z_ARRVAL_P(subject);
44270 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
44271 } else {
44272 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
44273 subject = Z_REFVAL_P(subject);
44274 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
44275 goto array_key_exists_array;
44276 }
44277 }
44278 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
44279 result = 0;
44280 }
44281
44282
44283 ZEND_VM_SMART_BRANCH(result, 1);
44284 }
44285
44286 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44287 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44288 {
44289 USE_OPLINE
44290 zval *expr;
44291 bool result;
44292
44293 SAVE_OPLINE();
44294 expr = EX_VAR(opline->op1.var);
44295
44296 try_instanceof:
44297 if (Z_TYPE_P(expr) == IS_OBJECT) {
44298 zend_class_entry *ce;
44299
44300 if (IS_CONST == IS_CONST) {
44301 ce = CACHED_PTR(opline->extended_value);
44302 if (UNEXPECTED(ce == NULL)) {
44303 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);
44304 if (EXPECTED(ce)) {
44305 CACHE_PTR(opline->extended_value, ce);
44306 }
44307 }
44308 } else if (IS_CONST == IS_UNUSED) {
44309 ce = zend_fetch_class(NULL, opline->op2.num);
44310 if (UNEXPECTED(ce == NULL)) {
44311
44312 ZVAL_UNDEF(EX_VAR(opline->result.var));
44313 HANDLE_EXCEPTION();
44314 }
44315 } else {
44316 ce = Z_CE_P(EX_VAR(opline->op2.var));
44317 }
44318 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
44319 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
44320 expr = Z_REFVAL_P(expr);
44321 goto try_instanceof;
44322 } else {
44323 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
44324 ZVAL_UNDEFINED_OP1();
44325 }
44326 result = 0;
44327 }
44328
44329 ZEND_VM_SMART_BRANCH(result, 1);
44330 }
44331
ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44332 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44333 {
44334 USE_OPLINE
44335
44336 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
44337
44338 SAVE_OPLINE();
44339 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
44340 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
44341 }
44342
44343 /* Destroy the previously yielded value */
44344 zval_ptr_dtor(&generator->value);
44345
44346 /* Destroy the previously yielded key */
44347 zval_ptr_dtor(&generator->key);
44348
44349 /* Set the new yielded value */
44350 if (IS_CV != IS_UNUSED) {
44351 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
44352 /* Constants and temporary variables aren't yieldable by reference,
44353 * but we still allow them with a notice. */
44354 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
44355 zval *value;
44356
44357 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
44358
44359 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
44360 ZVAL_COPY_VALUE(&generator->value, value);
44361 if (IS_CV == IS_CONST) {
44362 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
44363 Z_ADDREF(generator->value);
44364 }
44365 }
44366 } else {
44367 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
44368
44369 /* If a function call result is yielded and the function did
44370 * not return by reference we throw a notice. */
44371 do {
44372 if (IS_CV == IS_VAR) {
44373 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
44374 if (opline->extended_value == ZEND_RETURNS_FUNCTION
44375 && !Z_ISREF_P(value_ptr)) {
44376 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
44377 ZVAL_COPY(&generator->value, value_ptr);
44378 break;
44379 }
44380 }
44381 if (Z_ISREF_P(value_ptr)) {
44382 Z_ADDREF_P(value_ptr);
44383 } else {
44384 ZVAL_MAKE_REF_EX(value_ptr, 2);
44385 }
44386 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
44387 } while (0);
44388
44389 }
44390 } else {
44391 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
44392
44393 /* Consts, temporary variables and references need copying */
44394 if (IS_CV == IS_CONST) {
44395 ZVAL_COPY_VALUE(&generator->value, value);
44396 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
44397 Z_ADDREF(generator->value);
44398 }
44399 } else if (IS_CV == IS_TMP_VAR) {
44400 ZVAL_COPY_VALUE(&generator->value, value);
44401 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
44402 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
44403
44404 } else {
44405 ZVAL_COPY_VALUE(&generator->value, value);
44406 if (IS_CV == IS_CV) {
44407 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
44408 }
44409 }
44410 }
44411 } else {
44412 /* If no value was specified yield null */
44413 ZVAL_NULL(&generator->value);
44414 }
44415
44416 /* Set the new yielded key */
44417 if (IS_CONST != IS_UNUSED) {
44418 zval *key = RT_CONSTANT(opline, opline->op2);
44419 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
44420 key = Z_REFVAL_P(key);
44421 }
44422 ZVAL_COPY(&generator->key, key);
44423
44424 if (Z_TYPE(generator->key) == IS_LONG
44425 && Z_LVAL(generator->key) > generator->largest_used_integer_key
44426 ) {
44427 generator->largest_used_integer_key = Z_LVAL(generator->key);
44428 }
44429 } else {
44430 /* If no key was specified we use auto-increment keys */
44431 generator->largest_used_integer_key++;
44432 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
44433 }
44434
44435 if (RETURN_VALUE_USED(opline)) {
44436 /* If the return value of yield is used set the send
44437 * target and initialize it to NULL */
44438 generator->send_target = EX_VAR(opline->result.var);
44439 ZVAL_NULL(generator->send_target);
44440 } else {
44441 generator->send_target = NULL;
44442 }
44443
44444 /* We increment to the next op, so we are at the correct position when the
44445 * generator is resumed. */
44446 ZEND_VM_INC_OPCODE();
44447
44448 /* The GOTO VM uses a local opline variable. We need to set the opline
44449 * variable in execute_data so we don't resume at an old position. */
44450 SAVE_OPLINE();
44451
44452 ZEND_VM_RETURN();
44453 }
44454
ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44455 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44456 {
44457 USE_OPLINE
44458 zend_string *varname;
44459 zval *value;
44460 zval *variable_ptr;
44461 uintptr_t idx;
44462 zend_reference *ref;
44463
44464 ZEND_VM_REPEATABLE_OPCODE
44465
44466 varname = Z_STR_P(RT_CONSTANT(opline, opline->op2));
44467
44468 /* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
44469 idx = (uintptr_t)CACHED_PTR(opline->extended_value) - 1;
44470 if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
44471 Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
44472
44473 if (EXPECTED(p->key == varname) ||
44474 (EXPECTED(p->h == ZSTR_H(varname)) &&
44475 EXPECTED(p->key != NULL) &&
44476 EXPECTED(zend_string_equal_content(p->key, varname)))) {
44477
44478 value = (zval*)p; /* value = &p->val; */
44479 goto check_indirect;
44480 }
44481 }
44482
44483 value = zend_hash_find_known_hash(&EG(symbol_table), varname);
44484 if (UNEXPECTED(value == NULL)) {
44485 value = zend_hash_add_new(&EG(symbol_table), varname, &EG(uninitialized_zval));
44486 idx = (char*)value - (char*)EG(symbol_table).arData;
44487 /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
44488 CACHE_PTR(opline->extended_value, (void*)(idx + 1));
44489 } else {
44490 idx = (char*)value - (char*)EG(symbol_table).arData;
44491 /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
44492 CACHE_PTR(opline->extended_value, (void*)(idx + 1));
44493 check_indirect:
44494 /* GLOBAL variable may be an INDIRECT pointer to CV */
44495 if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
44496 value = Z_INDIRECT_P(value);
44497 if (UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44498 ZVAL_NULL(value);
44499 }
44500 }
44501 }
44502
44503 if (UNEXPECTED(!Z_ISREF_P(value))) {
44504 ZVAL_MAKE_REF_EX(value, 2);
44505 ref = Z_REF_P(value);
44506 } else {
44507 ref = Z_REF_P(value);
44508 GC_ADDREF(ref);
44509 }
44510
44511 variable_ptr = EX_VAR(opline->op1.var);
44512
44513 if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
44514 zend_refcounted *garbage = Z_COUNTED_P(variable_ptr);
44515
44516 ZVAL_REF(variable_ptr, ref);
44517 SAVE_OPLINE();
44518 if (GC_DELREF(garbage) == 0) {
44519 rc_dtor_func(garbage);
44520 if (UNEXPECTED(EG(exception))) {
44521 ZVAL_NULL(variable_ptr);
44522 HANDLE_EXCEPTION();
44523 }
44524 } else {
44525 gc_check_possible_root(garbage);
44526 }
44527 } else {
44528 ZVAL_REF(variable_ptr, ref);
44529 }
44530
44531 ZEND_VM_REPEAT_OPCODE(ZEND_BIND_GLOBAL);
44532 ZEND_VM_NEXT_OPCODE();
44533 }
44534
ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44535 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44536 {
44537 USE_OPLINE
44538 zval *op1;
44539 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
44540 zval *result;
44541
44542 op1 = EX_VAR(opline->op1.var);
44543 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44544 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CV == IS_CONST);
44545 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44546 zval_ptr_dtor_str(op1);
44547 }
44548 ZEND_VM_SMART_BRANCH(result, 0);
44549 }
44550
44551 if (opline->extended_value) {
44552 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
44553 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
44554 ZEND_VM_SMART_BRANCH(result, 0);
44555 }
44556 SAVE_OPLINE();
44557 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
44558 op1 = Z_REFVAL_P(op1);
44559 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44560 result = zend_hash_find(ht, Z_STR_P(op1));
44561
44562 ZEND_VM_SMART_BRANCH(result, 0);
44563 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
44564 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
44565
44566 ZEND_VM_SMART_BRANCH(result, 0);
44567 }
44568 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
44569 ZVAL_UNDEFINED_OP1();
44570 }
44571 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
44572 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
44573 SAVE_OPLINE();
44574 ZVAL_UNDEFINED_OP1();
44575 if (UNEXPECTED(EG(exception) != NULL)) {
44576 HANDLE_EXCEPTION();
44577 }
44578 }
44579 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
44580 ZEND_VM_SMART_BRANCH(result, 0);
44581 } else {
44582 zend_string *key;
44583 zval key_tmp;
44584
44585 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
44586 op1 = Z_REFVAL_P(op1);
44587 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44588 result = zend_hash_find(ht, Z_STR_P(op1));
44589
44590 ZEND_VM_SMART_BRANCH(result, 0);
44591 }
44592 }
44593
44594 SAVE_OPLINE();
44595 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
44596 ZVAL_STR(&key_tmp, key);
44597 if (zend_compare(op1, &key_tmp) == 0) {
44598
44599 ZEND_VM_SMART_BRANCH(1, 1);
44600 }
44601 } ZEND_HASH_FOREACH_END();
44602 }
44603
44604 ZEND_VM_SMART_BRANCH(0, 1);
44605 }
44606
ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44607 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44608 {
44609 /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
44610 /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
44611 /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
44612 USE_OPLINE
44613 zval *op1, *op2;
44614 bool result;
44615
44616 op1 = EX_VAR(opline->op1.var);
44617 op2 = RT_CONSTANT(opline, opline->op2);
44618 result = fast_is_identical_function(op1, op2);
44619 /* Free is a no-op for const/cv */
44620 ZEND_VM_SMART_BRANCH(result, 0);
44621 }
44622
ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44623 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44624 {
44625 USE_OPLINE
44626 zval *op1, *op2;
44627 bool result;
44628
44629 op1 = EX_VAR(opline->op1.var);
44630 op2 = RT_CONSTANT(opline, opline->op2);
44631 result = fast_is_identical_function(op1, op2);
44632 /* Free is a no-op for const/cv */
44633 ZEND_VM_SMART_BRANCH(!result, 0);
44634 }
44635
ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44636 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44637 {
44638 USE_OPLINE
44639 zval *container, *dim, *value;
44640 zend_long offset;
44641 HashTable *ht;
44642
44643 container = EX_VAR(opline->op1.var);
44644 dim = RT_CONSTANT(opline, opline->op2);
44645 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44646 fetch_dim_r_index_array:
44647 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
44648 offset = Z_LVAL_P(dim);
44649 } else {
44650 SAVE_OPLINE();
44651 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
44652
44653 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44654 }
44655 ht = Z_ARRVAL_P(container);
44656 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
44657 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
44658 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44659 SAVE_OPLINE();
44660
44661 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44662 } else {
44663 ZEND_VM_NEXT_OPCODE();
44664 }
44665 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
44666 container = Z_REFVAL_P(container);
44667 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44668 goto fetch_dim_r_index_array;
44669 } else {
44670 goto fetch_dim_r_index_slow;
44671 }
44672 } else {
44673 fetch_dim_r_index_slow:
44674 SAVE_OPLINE();
44675 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44676 dim++;
44677 }
44678 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
44679
44680 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44681 }
44682
44683 fetch_dim_r_index_undef:
44684 ZVAL_NULL(EX_VAR(opline->result.var));
44685 SAVE_OPLINE();
44686 zend_undefined_offset(offset);
44687
44688 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44689 }
44690
ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44691 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44692 {
44693 USE_OPLINE
44694 zval *container, *dim, *value;
44695 zend_long offset;
44696 HashTable *ht;
44697
44698 container = EX_VAR(opline->op1.var);
44699 dim = EX_VAR(opline->op2.var);
44700 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44701 fetch_dim_r_index_array:
44702 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
44703 offset = Z_LVAL_P(dim);
44704 } else {
44705 SAVE_OPLINE();
44706 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
44707
44708 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44709 }
44710 ht = Z_ARRVAL_P(container);
44711 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
44712 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
44713 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44714 SAVE_OPLINE();
44715
44716 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44717 } else {
44718 ZEND_VM_NEXT_OPCODE();
44719 }
44720 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
44721 container = Z_REFVAL_P(container);
44722 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44723 goto fetch_dim_r_index_array;
44724 } else {
44725 goto fetch_dim_r_index_slow;
44726 }
44727 } else {
44728 fetch_dim_r_index_slow:
44729 SAVE_OPLINE();
44730 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44731 dim++;
44732 }
44733 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
44734
44735 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44736 }
44737
44738 fetch_dim_r_index_undef:
44739 ZVAL_NULL(EX_VAR(opline->result.var));
44740 SAVE_OPLINE();
44741 zend_undefined_offset(offset);
44742
44743 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44744 }
44745
ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44746 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44747 {
44748 USE_OPLINE
44749 zval *op1, *op2;
44750
44751 SAVE_OPLINE();
44752 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
44753 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44754 div_function(EX_VAR(opline->result.var), op1, op2);
44755
44756 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
44757 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44758 }
44759
ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44760 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44761 {
44762 USE_OPLINE
44763 zval *op1, *op2;
44764
44765 SAVE_OPLINE();
44766 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
44767 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44768 pow_function(EX_VAR(opline->result.var), op1, op2);
44769
44770 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
44771 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44772 }
44773
ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44774 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44775 {
44776 USE_OPLINE
44777 zval *op1, *op2;
44778
44779 op1 = EX_VAR(opline->op1.var);
44780 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44781
44782 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
44783 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
44784 zend_string *op1_str = Z_STR_P(op1);
44785 zend_string *op2_str = Z_STR_P(op2);
44786 zend_string *str;
44787 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
44788
44789 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
44790 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
44791 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
44792 } else {
44793 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
44794 }
44795 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44796 zend_string_release_ex(op1_str, 0);
44797 }
44798 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
44799 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
44800 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
44801 } else {
44802 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
44803 }
44804 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44805 zend_string_release_ex(op2_str, 0);
44806 }
44807 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
44808 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
44809 size_t len = ZSTR_LEN(op1_str);
44810
44811 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
44812 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
44813 }
44814 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
44815 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44816 GC_ADD_FLAGS(str, flags);
44817 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44818 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44819 zend_string_release_ex(op2_str, 0);
44820 }
44821 } else {
44822 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
44823 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
44824 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44825 GC_ADD_FLAGS(str, flags);
44826 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44827 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44828 zend_string_release_ex(op1_str, 0);
44829 }
44830 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44831 zend_string_release_ex(op2_str, 0);
44832 }
44833 }
44834 ZEND_VM_NEXT_OPCODE();
44835 } else {
44836 SAVE_OPLINE();
44837
44838 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
44839 op1 = ZVAL_UNDEFINED_OP1();
44840 }
44841 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
44842 op2 = ZVAL_UNDEFINED_OP2();
44843 }
44844 concat_function(EX_VAR(opline->result.var), op1, op2);
44845
44846 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
44847 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44848 }
44849 }
44850
ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44851 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44852 {
44853 USE_OPLINE
44854 zval *op1, *op2;
44855 double d1, d2;
44856
44857 op1 = EX_VAR(opline->op1.var);
44858 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44859 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
44860 /* pass */
44861 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
44862 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44863 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
44864 is_equal_true:
44865 ZEND_VM_SMART_BRANCH_TRUE_NONE();
44866 } else {
44867 is_equal_false:
44868 ZEND_VM_SMART_BRANCH_FALSE_NONE();
44869 }
44870 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44871 d1 = (double)Z_LVAL_P(op1);
44872 d2 = Z_DVAL_P(op2);
44873 goto is_equal_double;
44874 }
44875 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
44876 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44877 d1 = Z_DVAL_P(op1);
44878 d2 = Z_DVAL_P(op2);
44879 is_equal_double:
44880 if (d1 == d2) {
44881 goto is_equal_true;
44882 } else {
44883 goto is_equal_false;
44884 }
44885 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44886 d1 = Z_DVAL_P(op1);
44887 d2 = (double)Z_LVAL_P(op2);
44888 goto is_equal_double;
44889 }
44890 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44891 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
44892 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
44893 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44894 zval_ptr_dtor_str(op1);
44895 }
44896 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44897 zval_ptr_dtor_str(op2);
44898 }
44899 if (result) {
44900 goto is_equal_true;
44901 } else {
44902 goto is_equal_false;
44903 }
44904 }
44905 }
44906 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
44907 }
44908
ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44909 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44910 {
44911 USE_OPLINE
44912 zval *op1, *op2;
44913 double d1, d2;
44914
44915 op1 = EX_VAR(opline->op1.var);
44916 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44917 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
44918 /* pass */
44919 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
44920 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44921 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
44922 is_equal_true:
44923 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
44924 } else {
44925 is_equal_false:
44926 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
44927 }
44928 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44929 d1 = (double)Z_LVAL_P(op1);
44930 d2 = Z_DVAL_P(op2);
44931 goto is_equal_double;
44932 }
44933 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
44934 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44935 d1 = Z_DVAL_P(op1);
44936 d2 = Z_DVAL_P(op2);
44937 is_equal_double:
44938 if (d1 == d2) {
44939 goto is_equal_true;
44940 } else {
44941 goto is_equal_false;
44942 }
44943 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44944 d1 = Z_DVAL_P(op1);
44945 d2 = (double)Z_LVAL_P(op2);
44946 goto is_equal_double;
44947 }
44948 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44949 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
44950 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
44951 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44952 zval_ptr_dtor_str(op1);
44953 }
44954 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44955 zval_ptr_dtor_str(op2);
44956 }
44957 if (result) {
44958 goto is_equal_true;
44959 } else {
44960 goto is_equal_false;
44961 }
44962 }
44963 }
44964 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
44965 }
44966
ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44967 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44968 {
44969 USE_OPLINE
44970 zval *op1, *op2;
44971 double d1, d2;
44972
44973 op1 = EX_VAR(opline->op1.var);
44974 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44975 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
44976 /* pass */
44977 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
44978 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44979 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
44980 is_equal_true:
44981 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
44982 } else {
44983 is_equal_false:
44984 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
44985 }
44986 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44987 d1 = (double)Z_LVAL_P(op1);
44988 d2 = Z_DVAL_P(op2);
44989 goto is_equal_double;
44990 }
44991 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
44992 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44993 d1 = Z_DVAL_P(op1);
44994 d2 = Z_DVAL_P(op2);
44995 is_equal_double:
44996 if (d1 == d2) {
44997 goto is_equal_true;
44998 } else {
44999 goto is_equal_false;
45000 }
45001 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45002 d1 = Z_DVAL_P(op1);
45003 d2 = (double)Z_LVAL_P(op2);
45004 goto is_equal_double;
45005 }
45006 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45007 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
45008 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
45009 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45010 zval_ptr_dtor_str(op1);
45011 }
45012 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
45013 zval_ptr_dtor_str(op2);
45014 }
45015 if (result) {
45016 goto is_equal_true;
45017 } else {
45018 goto is_equal_false;
45019 }
45020 }
45021 }
45022 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
45023 }
45024
ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45025 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45026 {
45027 USE_OPLINE
45028 zval *op1, *op2;
45029 double d1, d2;
45030
45031 op1 = EX_VAR(opline->op1.var);
45032 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45033 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
45034 /* pass */
45035 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45036 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45037 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
45038 is_not_equal_true:
45039 ZEND_VM_SMART_BRANCH_TRUE_NONE();
45040 } else {
45041 is_not_equal_false:
45042 ZEND_VM_SMART_BRANCH_FALSE_NONE();
45043 }
45044 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45045 d1 = (double)Z_LVAL_P(op1);
45046 d2 = Z_DVAL_P(op2);
45047 goto is_not_equal_double;
45048 }
45049 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
45050 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45051 d1 = Z_DVAL_P(op1);
45052 d2 = Z_DVAL_P(op2);
45053 is_not_equal_double:
45054 if (d1 != d2) {
45055 goto is_not_equal_true;
45056 } else {
45057 goto is_not_equal_false;
45058 }
45059 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45060 d1 = Z_DVAL_P(op1);
45061 d2 = (double)Z_LVAL_P(op2);
45062 goto is_not_equal_double;
45063 }
45064 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45065 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
45066 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
45067 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45068 zval_ptr_dtor_str(op1);
45069 }
45070 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
45071 zval_ptr_dtor_str(op2);
45072 }
45073 if (!result) {
45074 goto is_not_equal_true;
45075 } else {
45076 goto is_not_equal_false;
45077 }
45078 }
45079 }
45080 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
45081 }
45082
ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45083 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45084 {
45085 USE_OPLINE
45086 zval *op1, *op2;
45087 double d1, d2;
45088
45089 op1 = EX_VAR(opline->op1.var);
45090 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45091 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
45092 /* pass */
45093 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45094 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45095 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
45096 is_not_equal_true:
45097 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
45098 } else {
45099 is_not_equal_false:
45100 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
45101 }
45102 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45103 d1 = (double)Z_LVAL_P(op1);
45104 d2 = Z_DVAL_P(op2);
45105 goto is_not_equal_double;
45106 }
45107 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
45108 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45109 d1 = Z_DVAL_P(op1);
45110 d2 = Z_DVAL_P(op2);
45111 is_not_equal_double:
45112 if (d1 != d2) {
45113 goto is_not_equal_true;
45114 } else {
45115 goto is_not_equal_false;
45116 }
45117 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45118 d1 = Z_DVAL_P(op1);
45119 d2 = (double)Z_LVAL_P(op2);
45120 goto is_not_equal_double;
45121 }
45122 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45123 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
45124 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
45125 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45126 zval_ptr_dtor_str(op1);
45127 }
45128 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
45129 zval_ptr_dtor_str(op2);
45130 }
45131 if (!result) {
45132 goto is_not_equal_true;
45133 } else {
45134 goto is_not_equal_false;
45135 }
45136 }
45137 }
45138 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
45139 }
45140
ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45141 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45142 {
45143 USE_OPLINE
45144 zval *op1, *op2;
45145 double d1, d2;
45146
45147 op1 = EX_VAR(opline->op1.var);
45148 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45149 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
45150 /* pass */
45151 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45152 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45153 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
45154 is_not_equal_true:
45155 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
45156 } else {
45157 is_not_equal_false:
45158 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
45159 }
45160 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45161 d1 = (double)Z_LVAL_P(op1);
45162 d2 = Z_DVAL_P(op2);
45163 goto is_not_equal_double;
45164 }
45165 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
45166 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45167 d1 = Z_DVAL_P(op1);
45168 d2 = Z_DVAL_P(op2);
45169 is_not_equal_double:
45170 if (d1 != d2) {
45171 goto is_not_equal_true;
45172 } else {
45173 goto is_not_equal_false;
45174 }
45175 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45176 d1 = Z_DVAL_P(op1);
45177 d2 = (double)Z_LVAL_P(op2);
45178 goto is_not_equal_double;
45179 }
45180 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45181 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
45182 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
45183 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45184 zval_ptr_dtor_str(op1);
45185 }
45186 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
45187 zval_ptr_dtor_str(op2);
45188 }
45189 if (!result) {
45190 goto is_not_equal_true;
45191 } else {
45192 goto is_not_equal_false;
45193 }
45194 }
45195 }
45196 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
45197 }
45198
ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45199 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45200 {
45201 USE_OPLINE
45202 zval *op1, *op2;
45203
45204 SAVE_OPLINE();
45205 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45206 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45207 compare_function(EX_VAR(opline->result.var), op1, op2);
45208
45209 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45210 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45211 }
45212
ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45213 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45214 {
45215 USE_OPLINE
45216 zval *op1, *op2;
45217
45218 SAVE_OPLINE();
45219 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45220 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45221 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
45222
45223 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45224 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45225 }
45226
ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45227 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45228 {
45229 USE_OPLINE
45230 zval *object;
45231 zval *property;
45232 zval *value;
45233 zval *zptr;
45234 void **cache_slot;
45235 zend_property_info *prop_info;
45236 zend_object *zobj;
45237 zend_string *name, *tmp_name;
45238
45239 SAVE_OPLINE();
45240 object = EX_VAR(opline->op1.var);
45241 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45242
45243 do {
45244 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
45245
45246 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
45247 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
45248 object = Z_REFVAL_P(object);
45249 goto assign_op_object;
45250 }
45251 if (IS_CV == IS_CV
45252 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
45253 ZVAL_UNDEFINED_OP1();
45254 }
45255 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
45256 break;
45257 }
45258
45259 assign_op_object:
45260 /* here we are sure we are dealing with an object */
45261 zobj = Z_OBJ_P(object);
45262 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45263 name = Z_STR_P(property);
45264 } else {
45265 name = zval_try_get_tmp_string(property, &tmp_name);
45266 if (UNEXPECTED(!name)) {
45267 UNDEF_RESULT();
45268 break;
45269 }
45270 }
45271 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
45272 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
45273 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
45274 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45275 ZVAL_NULL(EX_VAR(opline->result.var));
45276 }
45277 } else {
45278 zval *orig_zptr = zptr;
45279 zend_reference *ref;
45280
45281 do {
45282 if (UNEXPECTED(Z_ISREF_P(zptr))) {
45283 ref = Z_REF_P(zptr);
45284 zptr = Z_REFVAL_P(zptr);
45285 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
45286 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
45287 break;
45288 }
45289 }
45290
45291 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45292 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
45293 } else {
45294 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
45295 }
45296 if (prop_info) {
45297 /* special case for typed properties */
45298 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
45299 } else {
45300 zend_binary_op(zptr, zptr, value OPLINE_CC);
45301 }
45302 } while (0);
45303
45304 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45305 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
45306 }
45307 }
45308 } else {
45309 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
45310 }
45311 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
45312 zend_tmp_string_release(tmp_name);
45313 }
45314 } while (0);
45315
45316 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
45317 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45318
45319 /* assign_obj has two opcodes! */
45320 ZEND_VM_NEXT_OPCODE_EX(1, 2);
45321 }
45322
45323 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45324 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45325 {
45326 USE_OPLINE
45327 zval *var_ptr;
45328 zval *value, *container, *dim;
45329 HashTable *ht;
45330
45331 SAVE_OPLINE();
45332 container = EX_VAR(opline->op1.var);
45333
45334 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45335 assign_dim_op_array:
45336 SEPARATE_ARRAY(container);
45337 ht = Z_ARRVAL_P(container);
45338 assign_dim_op_new_array:
45339 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45340 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
45341 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
45342 if (UNEXPECTED(!var_ptr)) {
45343 zend_cannot_add_element();
45344 goto assign_dim_op_ret_null;
45345 }
45346 } else {
45347 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45348 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
45349 } else {
45350 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
45351 }
45352 if (UNEXPECTED(!var_ptr)) {
45353 goto assign_dim_op_ret_null;
45354 }
45355 }
45356
45357 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
45358
45359 do {
45360 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
45361 zend_reference *ref = Z_REF_P(var_ptr);
45362 var_ptr = Z_REFVAL_P(var_ptr);
45363 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
45364 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
45365 break;
45366 }
45367 }
45368 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
45369 } while (0);
45370
45371 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45372 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
45373 }
45374 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
45375 } else {
45376 if (EXPECTED(Z_ISREF_P(container))) {
45377 container = Z_REFVAL_P(container);
45378 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45379 goto assign_dim_op_array;
45380 }
45381 }
45382
45383 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
45384 zend_object *obj = Z_OBJ_P(container);
45385
45386 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45387 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
45388 dim++;
45389 }
45390 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
45391 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
45392 uint8_t old_type;
45393
45394 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
45395 ZVAL_UNDEFINED_OP1();
45396 }
45397 ht = zend_new_array(8);
45398 old_type = Z_TYPE_P(container);
45399 ZVAL_ARR(container, ht);
45400 if (UNEXPECTED(old_type == IS_FALSE)) {
45401 GC_ADDREF(ht);
45402 zend_false_to_array_deprecated();
45403 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
45404 zend_array_destroy(ht);
45405 goto assign_dim_op_ret_null;
45406 }
45407 }
45408 goto assign_dim_op_new_array;
45409 } else {
45410 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45411 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
45412 assign_dim_op_ret_null:
45413 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
45414 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45415 ZVAL_NULL(EX_VAR(opline->result.var));
45416 }
45417 }
45418 }
45419
45420 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45421
45422 ZEND_VM_NEXT_OPCODE_EX(1, 2);
45423 }
45424
ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45425 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45426 {
45427 USE_OPLINE
45428 zval *var_ptr;
45429 zval *value;
45430
45431 SAVE_OPLINE();
45432 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45433 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
45434
45435 do {
45436 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
45437 zend_reference *ref = Z_REF_P(var_ptr);
45438 var_ptr = Z_REFVAL_P(var_ptr);
45439 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
45440 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
45441 break;
45442 }
45443 }
45444 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
45445 } while (0);
45446
45447 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45448 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
45449 }
45450
45451 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45452
45453 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45454 }
45455
ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45456 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45457 {
45458 USE_OPLINE
45459 zval *object;
45460 zval *property;
45461 zval *zptr;
45462 void **cache_slot;
45463 zend_property_info *prop_info;
45464 zend_object *zobj;
45465 zend_string *name, *tmp_name;
45466
45467 SAVE_OPLINE();
45468 object = EX_VAR(opline->op1.var);
45469 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45470
45471 do {
45472 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
45473 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
45474 object = Z_REFVAL_P(object);
45475 goto pre_incdec_object;
45476 }
45477 if (IS_CV == IS_CV
45478 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
45479 ZVAL_UNDEFINED_OP1();
45480 }
45481 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
45482 break;
45483 }
45484
45485 pre_incdec_object:
45486 /* here we are sure we are dealing with an object */
45487 zobj = Z_OBJ_P(object);
45488 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45489 name = Z_STR_P(property);
45490 } else {
45491 name = zval_try_get_tmp_string(property, &tmp_name);
45492 if (UNEXPECTED(!name)) {
45493 UNDEF_RESULT();
45494 break;
45495 }
45496 }
45497 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
45498 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
45499 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
45500 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45501 ZVAL_NULL(EX_VAR(opline->result.var));
45502 }
45503 } else {
45504 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45505 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
45506 } else {
45507 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
45508 }
45509 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
45510 }
45511 } else {
45512 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
45513 }
45514 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
45515 zend_tmp_string_release(tmp_name);
45516 }
45517 } while (0);
45518
45519 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45520
45521 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45522 }
45523
ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45524 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45525 {
45526 USE_OPLINE
45527 zval *object;
45528 zval *property;
45529 zval *zptr;
45530 void **cache_slot;
45531 zend_property_info *prop_info;
45532 zend_object *zobj;
45533 zend_string *name, *tmp_name;
45534
45535 SAVE_OPLINE();
45536 object = EX_VAR(opline->op1.var);
45537 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45538
45539 do {
45540 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
45541 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
45542 object = Z_REFVAL_P(object);
45543 goto post_incdec_object;
45544 }
45545 if (IS_CV == IS_CV
45546 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
45547 ZVAL_UNDEFINED_OP1();
45548 }
45549 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
45550 break;
45551 }
45552
45553 post_incdec_object:
45554 /* here we are sure we are dealing with an object */
45555 zobj = Z_OBJ_P(object);
45556 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45557 name = Z_STR_P(property);
45558 } else {
45559 name = zval_try_get_tmp_string(property, &tmp_name);
45560 if (UNEXPECTED(!name)) {
45561 ZVAL_UNDEF(EX_VAR(opline->result.var));
45562 break;
45563 }
45564 }
45565 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
45566 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
45567 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
45568 ZVAL_NULL(EX_VAR(opline->result.var));
45569 } else {
45570 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45571 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
45572 } else {
45573 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
45574 }
45575
45576 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
45577 }
45578 } else {
45579 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
45580 }
45581 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
45582 zend_tmp_string_release(tmp_name);
45583 }
45584 } while (0);
45585
45586 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45587
45588 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45589 }
45590
ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45591 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45592 {
45593 USE_OPLINE
45594 zval *container, *dim, *value;
45595
45596 SAVE_OPLINE();
45597 container = EX_VAR(opline->op1.var);
45598 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45599 if (IS_CV != IS_CONST) {
45600 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45601 fetch_dim_r_array:
45602 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
45603 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
45604 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
45605 container = Z_REFVAL_P(container);
45606 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45607 goto fetch_dim_r_array;
45608 } else {
45609 goto fetch_dim_r_slow;
45610 }
45611 } else {
45612 fetch_dim_r_slow:
45613 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
45614 dim++;
45615 }
45616 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
45617 }
45618 } else {
45619 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
45620 }
45621 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45622
45623 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45624 }
45625
ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45626 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45627 {
45628 USE_OPLINE
45629 zval *container;
45630
45631 SAVE_OPLINE();
45632 container = EX_VAR(opline->op1.var);
45633 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);
45634 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45635 if (IS_CV == IS_VAR) {
45636 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45637 }
45638 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45639 }
45640
ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45641 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45642 {
45643 USE_OPLINE
45644 zval *container;
45645
45646 SAVE_OPLINE();
45647 container = EX_VAR(opline->op1.var);
45648 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);
45649 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45650 if (IS_CV == IS_VAR) {
45651 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45652 }
45653 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45654 }
45655
ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45656 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45657 {
45658 USE_OPLINE
45659 zval *container;
45660
45661 SAVE_OPLINE();
45662 container = EX_VAR(opline->op1.var);
45663 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);
45664 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45665
45666 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45667 }
45668
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45669 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45670 {
45671 #if 0
45672 USE_OPLINE
45673 #endif
45674
45675 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
45676 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
45677 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45678 }
45679 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45680 } else {
45681 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
45682 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45683 }
45684 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45685 }
45686 }
45687
ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45688 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45689 {
45690 USE_OPLINE
45691 zval *container;
45692
45693 SAVE_OPLINE();
45694 container = EX_VAR(opline->op1.var);
45695 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);
45696 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45697 if (IS_CV == IS_VAR) {
45698 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45699 }
45700 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45701 }
45702
ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45703 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45704 {
45705 USE_OPLINE
45706 zval *container;
45707 void **cache_slot = NULL;
45708
45709 SAVE_OPLINE();
45710 container = EX_VAR(opline->op1.var);
45711
45712 if (IS_CV == IS_CONST ||
45713 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
45714 do {
45715 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
45716 container = Z_REFVAL_P(container);
45717 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
45718 break;
45719 }
45720 }
45721 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
45722 ZVAL_UNDEFINED_OP1();
45723 }
45724 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
45725 ZVAL_NULL(EX_VAR(opline->result.var));
45726 goto fetch_obj_r_finish;
45727 } while (0);
45728 }
45729
45730 /* here we are sure we are dealing with an object */
45731 do {
45732 zend_object *zobj = Z_OBJ_P(container);
45733 zend_string *name, *tmp_name;
45734 zval *retval;
45735
45736 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45737 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
45738
45739 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
45740 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
45741
45742 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
45743 retval = OBJ_PROP(zobj, prop_offset);
45744 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
45745 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45746 goto fetch_obj_r_copy;
45747 } else {
45748 fetch_obj_r_fast_copy:
45749 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
45750 ZEND_VM_NEXT_OPCODE();
45751 }
45752 }
45753 } else if (EXPECTED(zobj->properties != NULL)) {
45754 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
45755 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
45756 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
45757
45758 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
45759 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
45760
45761 if (EXPECTED(p->key == name) ||
45762 (EXPECTED(p->h == ZSTR_H(name)) &&
45763 EXPECTED(p->key != NULL) &&
45764 EXPECTED(zend_string_equal_content(p->key, name)))) {
45765 retval = &p->val;
45766 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45767 goto fetch_obj_r_copy;
45768 } else {
45769 goto fetch_obj_r_fast_copy;
45770 }
45771 }
45772 }
45773 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
45774 }
45775 retval = zend_hash_find_known_hash(zobj->properties, name);
45776 if (EXPECTED(retval)) {
45777 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
45778 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
45779 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45780 goto fetch_obj_r_copy;
45781 } else {
45782 goto fetch_obj_r_fast_copy;
45783 }
45784 }
45785 }
45786 }
45787 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
45788 } else {
45789 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
45790 if (UNEXPECTED(!name)) {
45791 ZVAL_UNDEF(EX_VAR(opline->result.var));
45792 break;
45793 }
45794 }
45795
45796 #if ZEND_DEBUG
45797 /* For non-standard object handlers, verify a declared property type in debug builds.
45798 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
45799 zend_property_info *prop_info = NULL;
45800 if (zobj->handlers->read_property != zend_std_read_property) {
45801 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
45802 }
45803 #endif
45804 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
45805 #if ZEND_DEBUG
45806 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
45807 && ZEND_TYPE_IS_SET(prop_info->type)) {
45808 ZVAL_OPT_DEREF(retval);
45809 zend_verify_property_type(prop_info, retval, /* strict */ true);
45810 }
45811 #endif
45812
45813 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
45814 zend_tmp_string_release(tmp_name);
45815 }
45816
45817 if (retval != EX_VAR(opline->result.var)) {
45818 fetch_obj_r_copy:
45819 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
45820 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
45821 zend_unwrap_reference(retval);
45822 }
45823 } while (0);
45824
45825 fetch_obj_r_finish:
45826 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45827
45828 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45829 }
45830
ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45831 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45832 {
45833 USE_OPLINE
45834 zval *property, *container, *result;
45835
45836 SAVE_OPLINE();
45837
45838 container = EX_VAR(opline->op1.var);
45839 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45840 result = EX_VAR(opline->result.var);
45841 zend_fetch_property_address(
45842 result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR),
45843 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
45844 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
45845 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45846 if (IS_CV == IS_VAR) {
45847 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45848 }
45849 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45850 }
45851
ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45852 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45853 {
45854 USE_OPLINE
45855 zval *property, *container, *result;
45856
45857 SAVE_OPLINE();
45858 container = EX_VAR(opline->op1.var);
45859 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45860 result = EX_VAR(opline->result.var);
45861 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);
45862 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45863 if (IS_CV == IS_VAR) {
45864 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45865 }
45866 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45867 }
45868
ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45869 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45870 {
45871 USE_OPLINE
45872 zval *container;
45873 void **cache_slot = NULL;
45874
45875 SAVE_OPLINE();
45876 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
45877
45878 if (IS_CV == IS_CONST ||
45879 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
45880 do {
45881 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
45882 container = Z_REFVAL_P(container);
45883 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
45884 break;
45885 }
45886 }
45887 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
45888 ZVAL_UNDEFINED_OP2();
45889 }
45890 ZVAL_NULL(EX_VAR(opline->result.var));
45891 goto fetch_obj_is_finish;
45892 } while (0);
45893 }
45894
45895 /* here we are sure we are dealing with an object */
45896 do {
45897 zend_object *zobj = Z_OBJ_P(container);
45898 zend_string *name, *tmp_name;
45899 zval *retval;
45900
45901 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45902 cache_slot = CACHE_ADDR(opline->extended_value);
45903
45904 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
45905 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
45906
45907 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
45908 retval = OBJ_PROP(zobj, prop_offset);
45909 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
45910 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45911 goto fetch_obj_is_copy;
45912 } else {
45913 fetch_obj_is_fast_copy:
45914 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
45915 ZEND_VM_NEXT_OPCODE();
45916 }
45917 }
45918 } else if (EXPECTED(zobj->properties != NULL)) {
45919 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
45920 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
45921 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
45922
45923 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
45924 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
45925
45926 if (EXPECTED(p->key == name) ||
45927 (EXPECTED(p->h == ZSTR_H(name)) &&
45928 EXPECTED(p->key != NULL) &&
45929 EXPECTED(zend_string_equal_content(p->key, name)))) {
45930 retval = &p->val;
45931 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45932 goto fetch_obj_is_copy;
45933 } else {
45934 goto fetch_obj_is_fast_copy;
45935 }
45936 }
45937 }
45938 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
45939 }
45940 retval = zend_hash_find_known_hash(zobj->properties, name);
45941 if (EXPECTED(retval)) {
45942 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
45943 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
45944 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45945 goto fetch_obj_is_copy;
45946 } else {
45947 goto fetch_obj_is_fast_copy;
45948 }
45949 }
45950 }
45951 }
45952 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
45953 } else {
45954 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
45955 if (UNEXPECTED(!name)) {
45956 ZVAL_UNDEF(EX_VAR(opline->result.var));
45957 break;
45958 }
45959 }
45960
45961 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
45962
45963 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
45964 zend_tmp_string_release(tmp_name);
45965 }
45966
45967 if (retval != EX_VAR(opline->result.var)) {
45968 fetch_obj_is_copy:
45969 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
45970 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
45971 zend_unwrap_reference(retval);
45972 }
45973 } while (0);
45974
45975 fetch_obj_is_finish:
45976 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45977
45978 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45979 }
45980
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45981 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45982 {
45983 #if 0
45984 USE_OPLINE
45985 #endif
45986
45987 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
45988 /* Behave like FETCH_OBJ_W */
45989 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
45990 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45991 }
45992 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45993 } else {
45994 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45995 }
45996 }
45997
ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45998 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45999 {
46000 USE_OPLINE
46001 zval *container, *property, *result;
46002
46003 SAVE_OPLINE();
46004 container = EX_VAR(opline->op1.var);
46005 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46006 result = EX_VAR(opline->result.var);
46007 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);
46008 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46009 if (IS_CV == IS_VAR) {
46010 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46011 }
46012 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46013 }
46014
ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46015 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46016 {
46017 USE_OPLINE
46018 zval *object, *value, tmp;
46019 zend_object *zobj;
46020 zend_string *name, *tmp_name;
46021 zend_refcounted *garbage = NULL;
46022
46023 SAVE_OPLINE();
46024 object = EX_VAR(opline->op1.var);
46025 value = RT_CONSTANT((opline+1), (opline+1)->op1);
46026
46027 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46028 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46029 object = Z_REFVAL_P(object);
46030 goto assign_object;
46031 }
46032 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
46033 value = &EG(uninitialized_zval);
46034 goto free_and_exit_assign_obj;
46035 }
46036
46037 assign_object:
46038 zobj = Z_OBJ_P(object);
46039 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46040 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
46041 void **cache_slot = CACHE_ADDR(opline->extended_value);
46042 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
46043 zval *property_val;
46044
46045 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
46046 property_val = OBJ_PROP(zobj, prop_offset);
46047 if (Z_TYPE_P(property_val) != IS_UNDEF) {
46048 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
46049
46050 if (prop_info != NULL) {
46051 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
46052 goto free_and_exit_assign_obj;
46053 } else {
46054 fast_assign_obj:
46055 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
46056 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46057 ZVAL_COPY(EX_VAR(opline->result.var), value);
46058 }
46059 goto exit_assign_obj;
46060 }
46061 }
46062 } else {
46063 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46064 if (EXPECTED(zobj->properties != NULL)) {
46065 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
46066 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
46067 GC_DELREF(zobj->properties);
46068 }
46069 zobj->properties = zend_array_dup(zobj->properties);
46070 }
46071 property_val = zend_hash_find_known_hash(zobj->properties, name);
46072 if (property_val) {
46073 goto fast_assign_obj;
46074 }
46075 }
46076
46077 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
46078 if (EXPECTED(zobj->properties == NULL)) {
46079 rebuild_object_properties(zobj);
46080 }
46081 if (IS_CONST == IS_CONST) {
46082 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
46083 Z_ADDREF_P(value);
46084 }
46085 } else if (IS_CONST != IS_TMP_VAR) {
46086 if (Z_ISREF_P(value)) {
46087 if (IS_CONST == IS_VAR) {
46088 zend_reference *ref = Z_REF_P(value);
46089 if (GC_DELREF(ref) == 0) {
46090 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
46091 efree_size(ref, sizeof(zend_reference));
46092 value = &tmp;
46093 } else {
46094 value = Z_REFVAL_P(value);
46095 Z_TRY_ADDREF_P(value);
46096 }
46097 } else {
46098 value = Z_REFVAL_P(value);
46099 Z_TRY_ADDREF_P(value);
46100 }
46101 } else if (IS_CONST == IS_CV) {
46102 Z_TRY_ADDREF_P(value);
46103 }
46104 }
46105 zend_hash_add_new(zobj->properties, name, value);
46106 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46107 ZVAL_COPY(EX_VAR(opline->result.var), value);
46108 }
46109 goto exit_assign_obj;
46110 }
46111 }
46112 }
46113 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46114 } else {
46115 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
46116 if (UNEXPECTED(!name)) {
46117
46118 UNDEF_RESULT();
46119 goto exit_assign_obj;
46120 }
46121 }
46122
46123 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
46124 ZVAL_DEREF(value);
46125 }
46126
46127 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
46128
46129 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46130 zend_tmp_string_release(tmp_name);
46131 }
46132
46133 free_and_exit_assign_obj:
46134 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
46135 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46136 }
46137
46138 exit_assign_obj:
46139 if (garbage) {
46140 GC_DTOR_NO_REF(garbage);
46141 }
46142 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46143
46144 /* assign_obj has two opcodes! */
46145 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46146 }
46147
46148 /* 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)46149 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46150 {
46151 USE_OPLINE
46152 zval *object, *value, tmp;
46153 zend_object *zobj;
46154 zend_string *name, *tmp_name;
46155 zend_refcounted *garbage = NULL;
46156
46157 SAVE_OPLINE();
46158 object = EX_VAR(opline->op1.var);
46159 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
46160
46161 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46162 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46163 object = Z_REFVAL_P(object);
46164 goto assign_object;
46165 }
46166 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
46167 value = &EG(uninitialized_zval);
46168 goto free_and_exit_assign_obj;
46169 }
46170
46171 assign_object:
46172 zobj = Z_OBJ_P(object);
46173 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46174 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
46175 void **cache_slot = CACHE_ADDR(opline->extended_value);
46176 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
46177 zval *property_val;
46178
46179 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
46180 property_val = OBJ_PROP(zobj, prop_offset);
46181 if (Z_TYPE_P(property_val) != IS_UNDEF) {
46182 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
46183
46184 if (prop_info != NULL) {
46185 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
46186 goto free_and_exit_assign_obj;
46187 } else {
46188 fast_assign_obj:
46189 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
46190 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46191 ZVAL_COPY(EX_VAR(opline->result.var), value);
46192 }
46193 goto exit_assign_obj;
46194 }
46195 }
46196 } else {
46197 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46198 if (EXPECTED(zobj->properties != NULL)) {
46199 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
46200 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
46201 GC_DELREF(zobj->properties);
46202 }
46203 zobj->properties = zend_array_dup(zobj->properties);
46204 }
46205 property_val = zend_hash_find_known_hash(zobj->properties, name);
46206 if (property_val) {
46207 goto fast_assign_obj;
46208 }
46209 }
46210
46211 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
46212 if (EXPECTED(zobj->properties == NULL)) {
46213 rebuild_object_properties(zobj);
46214 }
46215 if (IS_TMP_VAR == IS_CONST) {
46216 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
46217 Z_ADDREF_P(value);
46218 }
46219 } else if (IS_TMP_VAR != IS_TMP_VAR) {
46220 if (Z_ISREF_P(value)) {
46221 if (IS_TMP_VAR == IS_VAR) {
46222 zend_reference *ref = Z_REF_P(value);
46223 if (GC_DELREF(ref) == 0) {
46224 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
46225 efree_size(ref, sizeof(zend_reference));
46226 value = &tmp;
46227 } else {
46228 value = Z_REFVAL_P(value);
46229 Z_TRY_ADDREF_P(value);
46230 }
46231 } else {
46232 value = Z_REFVAL_P(value);
46233 Z_TRY_ADDREF_P(value);
46234 }
46235 } else if (IS_TMP_VAR == IS_CV) {
46236 Z_TRY_ADDREF_P(value);
46237 }
46238 }
46239 zend_hash_add_new(zobj->properties, name, value);
46240 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46241 ZVAL_COPY(EX_VAR(opline->result.var), value);
46242 }
46243 goto exit_assign_obj;
46244 }
46245 }
46246 }
46247 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46248 } else {
46249 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
46250 if (UNEXPECTED(!name)) {
46251 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46252 UNDEF_RESULT();
46253 goto exit_assign_obj;
46254 }
46255 }
46256
46257 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
46258 ZVAL_DEREF(value);
46259 }
46260
46261 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
46262
46263 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46264 zend_tmp_string_release(tmp_name);
46265 }
46266
46267 free_and_exit_assign_obj:
46268 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
46269 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46270 }
46271 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46272 exit_assign_obj:
46273 if (garbage) {
46274 GC_DTOR_NO_REF(garbage);
46275 }
46276 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46277
46278 /* assign_obj has two opcodes! */
46279 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46280 }
46281
46282 /* 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)46283 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46284 {
46285 USE_OPLINE
46286 zval *object, *value, tmp;
46287 zend_object *zobj;
46288 zend_string *name, *tmp_name;
46289 zend_refcounted *garbage = NULL;
46290
46291 SAVE_OPLINE();
46292 object = EX_VAR(opline->op1.var);
46293 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
46294
46295 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46296 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46297 object = Z_REFVAL_P(object);
46298 goto assign_object;
46299 }
46300 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
46301 value = &EG(uninitialized_zval);
46302 goto free_and_exit_assign_obj;
46303 }
46304
46305 assign_object:
46306 zobj = Z_OBJ_P(object);
46307 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46308 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
46309 void **cache_slot = CACHE_ADDR(opline->extended_value);
46310 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
46311 zval *property_val;
46312
46313 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
46314 property_val = OBJ_PROP(zobj, prop_offset);
46315 if (Z_TYPE_P(property_val) != IS_UNDEF) {
46316 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
46317
46318 if (prop_info != NULL) {
46319 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
46320 goto free_and_exit_assign_obj;
46321 } else {
46322 fast_assign_obj:
46323 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
46324 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46325 ZVAL_COPY(EX_VAR(opline->result.var), value);
46326 }
46327 goto exit_assign_obj;
46328 }
46329 }
46330 } else {
46331 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46332 if (EXPECTED(zobj->properties != NULL)) {
46333 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
46334 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
46335 GC_DELREF(zobj->properties);
46336 }
46337 zobj->properties = zend_array_dup(zobj->properties);
46338 }
46339 property_val = zend_hash_find_known_hash(zobj->properties, name);
46340 if (property_val) {
46341 goto fast_assign_obj;
46342 }
46343 }
46344
46345 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
46346 if (EXPECTED(zobj->properties == NULL)) {
46347 rebuild_object_properties(zobj);
46348 }
46349 if (IS_VAR == IS_CONST) {
46350 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
46351 Z_ADDREF_P(value);
46352 }
46353 } else if (IS_VAR != IS_TMP_VAR) {
46354 if (Z_ISREF_P(value)) {
46355 if (IS_VAR == IS_VAR) {
46356 zend_reference *ref = Z_REF_P(value);
46357 if (GC_DELREF(ref) == 0) {
46358 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
46359 efree_size(ref, sizeof(zend_reference));
46360 value = &tmp;
46361 } else {
46362 value = Z_REFVAL_P(value);
46363 Z_TRY_ADDREF_P(value);
46364 }
46365 } else {
46366 value = Z_REFVAL_P(value);
46367 Z_TRY_ADDREF_P(value);
46368 }
46369 } else if (IS_VAR == IS_CV) {
46370 Z_TRY_ADDREF_P(value);
46371 }
46372 }
46373 zend_hash_add_new(zobj->properties, name, value);
46374 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46375 ZVAL_COPY(EX_VAR(opline->result.var), value);
46376 }
46377 goto exit_assign_obj;
46378 }
46379 }
46380 }
46381 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46382 } else {
46383 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
46384 if (UNEXPECTED(!name)) {
46385 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46386 UNDEF_RESULT();
46387 goto exit_assign_obj;
46388 }
46389 }
46390
46391 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
46392 ZVAL_DEREF(value);
46393 }
46394
46395 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
46396
46397 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46398 zend_tmp_string_release(tmp_name);
46399 }
46400
46401 free_and_exit_assign_obj:
46402 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
46403 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46404 }
46405 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46406 exit_assign_obj:
46407 if (garbage) {
46408 GC_DTOR_NO_REF(garbage);
46409 }
46410 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46411
46412 /* assign_obj has two opcodes! */
46413 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46414 }
46415
46416 /* 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)46417 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46418 {
46419 USE_OPLINE
46420 zval *object, *value, tmp;
46421 zend_object *zobj;
46422 zend_string *name, *tmp_name;
46423 zend_refcounted *garbage = NULL;
46424
46425 SAVE_OPLINE();
46426 object = EX_VAR(opline->op1.var);
46427 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
46428
46429 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46430 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46431 object = Z_REFVAL_P(object);
46432 goto assign_object;
46433 }
46434 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
46435 value = &EG(uninitialized_zval);
46436 goto free_and_exit_assign_obj;
46437 }
46438
46439 assign_object:
46440 zobj = Z_OBJ_P(object);
46441 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46442 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
46443 void **cache_slot = CACHE_ADDR(opline->extended_value);
46444 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
46445 zval *property_val;
46446
46447 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
46448 property_val = OBJ_PROP(zobj, prop_offset);
46449 if (Z_TYPE_P(property_val) != IS_UNDEF) {
46450 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
46451
46452 if (prop_info != NULL) {
46453 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
46454 goto free_and_exit_assign_obj;
46455 } else {
46456 fast_assign_obj:
46457 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
46458 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46459 ZVAL_COPY(EX_VAR(opline->result.var), value);
46460 }
46461 goto exit_assign_obj;
46462 }
46463 }
46464 } else {
46465 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46466 if (EXPECTED(zobj->properties != NULL)) {
46467 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
46468 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
46469 GC_DELREF(zobj->properties);
46470 }
46471 zobj->properties = zend_array_dup(zobj->properties);
46472 }
46473 property_val = zend_hash_find_known_hash(zobj->properties, name);
46474 if (property_val) {
46475 goto fast_assign_obj;
46476 }
46477 }
46478
46479 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
46480 if (EXPECTED(zobj->properties == NULL)) {
46481 rebuild_object_properties(zobj);
46482 }
46483 if (IS_CV == IS_CONST) {
46484 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
46485 Z_ADDREF_P(value);
46486 }
46487 } else if (IS_CV != IS_TMP_VAR) {
46488 if (Z_ISREF_P(value)) {
46489 if (IS_CV == IS_VAR) {
46490 zend_reference *ref = Z_REF_P(value);
46491 if (GC_DELREF(ref) == 0) {
46492 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
46493 efree_size(ref, sizeof(zend_reference));
46494 value = &tmp;
46495 } else {
46496 value = Z_REFVAL_P(value);
46497 Z_TRY_ADDREF_P(value);
46498 }
46499 } else {
46500 value = Z_REFVAL_P(value);
46501 Z_TRY_ADDREF_P(value);
46502 }
46503 } else if (IS_CV == IS_CV) {
46504 Z_TRY_ADDREF_P(value);
46505 }
46506 }
46507 zend_hash_add_new(zobj->properties, name, value);
46508 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46509 ZVAL_COPY(EX_VAR(opline->result.var), value);
46510 }
46511 goto exit_assign_obj;
46512 }
46513 }
46514 }
46515 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46516 } else {
46517 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
46518 if (UNEXPECTED(!name)) {
46519
46520 UNDEF_RESULT();
46521 goto exit_assign_obj;
46522 }
46523 }
46524
46525 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
46526 ZVAL_DEREF(value);
46527 }
46528
46529 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
46530
46531 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46532 zend_tmp_string_release(tmp_name);
46533 }
46534
46535 free_and_exit_assign_obj:
46536 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
46537 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46538 }
46539
46540 exit_assign_obj:
46541 if (garbage) {
46542 GC_DTOR_NO_REF(garbage);
46543 }
46544 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46545
46546 /* assign_obj has two opcodes! */
46547 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46548 }
46549
46550 /* 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)46551 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46552 {
46553 USE_OPLINE
46554 zval *object_ptr, *orig_object_ptr;
46555 zval *value;
46556 zval *variable_ptr;
46557 zval *dim;
46558 zend_refcounted *garbage = NULL;
46559
46560 SAVE_OPLINE();
46561 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
46562
46563 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46564 try_assign_dim_array:
46565 SEPARATE_ARRAY(object_ptr);
46566 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46567 value = RT_CONSTANT((opline+1), (opline+1)->op1);
46568 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
46569 HashTable *ht = Z_ARRVAL_P(object_ptr);
46570 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
46571 GC_ADDREF(ht);
46572 }
46573 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46574 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
46575 zend_array_destroy(ht);
46576 goto assign_dim_error;
46577 }
46578 }
46579 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
46580 ZVAL_DEREF(value);
46581 }
46582 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
46583 if (UNEXPECTED(value == NULL)) {
46584 zend_cannot_add_element();
46585 goto assign_dim_error;
46586 } else if (IS_CONST == IS_CV) {
46587 if (Z_REFCOUNTED_P(value)) {
46588 Z_ADDREF_P(value);
46589 }
46590 } else if (IS_CONST == IS_VAR) {
46591 zval *free_op_data = EX_VAR((opline+1)->op1.var);
46592 if (Z_ISREF_P(free_op_data)) {
46593 if (Z_REFCOUNTED_P(value)) {
46594 Z_ADDREF_P(value);
46595 }
46596 zval_ptr_dtor_nogc(free_op_data);
46597 }
46598 } else if (IS_CONST == IS_CONST) {
46599 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
46600 Z_ADDREF_P(value);
46601 }
46602 }
46603 } else {
46604 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46605 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46606 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46607 } else {
46608 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46609 }
46610 if (UNEXPECTED(variable_ptr == NULL)) {
46611 goto assign_dim_error;
46612 }
46613 value = RT_CONSTANT((opline+1), (opline+1)->op1);
46614 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
46615 }
46616 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46617 ZVAL_COPY(EX_VAR(opline->result.var), value);
46618 }
46619 if (garbage) {
46620 GC_DTOR_NO_REF(garbage);
46621 }
46622 } else {
46623 if (EXPECTED(Z_ISREF_P(object_ptr))) {
46624 object_ptr = Z_REFVAL_P(object_ptr);
46625 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46626 goto try_assign_dim_array;
46627 }
46628 }
46629 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
46630 zend_object *obj = Z_OBJ_P(object_ptr);
46631
46632 GC_ADDREF(obj);
46633 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46634 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
46635 dim = ZVAL_UNDEFINED_OP2();
46636 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46637 dim++;
46638 }
46639
46640 value = RT_CONSTANT((opline+1), (opline+1)->op1);
46641 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
46642 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46643 } else if (IS_CONST & (IS_CV|IS_VAR)) {
46644 ZVAL_DEREF(value);
46645 }
46646
46647 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
46648
46649 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
46650 zend_objects_store_del(obj);
46651 }
46652 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
46653 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46654 zend_use_new_element_for_string();
46655
46656 UNDEF_RESULT();
46657 } else {
46658 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46659 value = RT_CONSTANT((opline+1), (opline+1)->op1);
46660 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
46661
46662 }
46663 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
46664 if (Z_ISREF_P(orig_object_ptr)
46665 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
46666 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
46667 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46668
46669 UNDEF_RESULT();
46670 } else {
46671 HashTable *ht = zend_new_array(8);
46672 uint8_t old_type = Z_TYPE_P(object_ptr);
46673
46674 ZVAL_ARR(object_ptr, ht);
46675 if (UNEXPECTED(old_type == IS_FALSE)) {
46676 GC_ADDREF(ht);
46677 zend_false_to_array_deprecated();
46678 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
46679 zend_array_destroy(ht);
46680 goto assign_dim_error;
46681 }
46682 }
46683 goto try_assign_dim_array;
46684 }
46685 } else {
46686 zend_use_scalar_as_array();
46687 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46688 assign_dim_error:
46689
46690 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46691 ZVAL_NULL(EX_VAR(opline->result.var));
46692 }
46693 }
46694 }
46695 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
46696 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46697 }
46698
46699 /* assign_dim has two opcodes! */
46700 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46701 }
46702
ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46703 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46704 {
46705 USE_OPLINE
46706 zval *object_ptr, *orig_object_ptr;
46707 zval *value;
46708 zval *variable_ptr;
46709 zval *dim;
46710 zend_refcounted *garbage = NULL;
46711
46712 SAVE_OPLINE();
46713 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
46714
46715 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46716 try_assign_dim_array:
46717 SEPARATE_ARRAY(object_ptr);
46718 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46719 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
46720 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
46721 HashTable *ht = Z_ARRVAL_P(object_ptr);
46722 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
46723 GC_ADDREF(ht);
46724 }
46725 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46726 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
46727 zend_array_destroy(ht);
46728 goto assign_dim_error;
46729 }
46730 }
46731 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
46732 ZVAL_DEREF(value);
46733 }
46734 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
46735 if (UNEXPECTED(value == NULL)) {
46736 zend_cannot_add_element();
46737 goto assign_dim_error;
46738 } else if (IS_TMP_VAR == IS_CV) {
46739 if (Z_REFCOUNTED_P(value)) {
46740 Z_ADDREF_P(value);
46741 }
46742 } else if (IS_TMP_VAR == IS_VAR) {
46743 zval *free_op_data = EX_VAR((opline+1)->op1.var);
46744 if (Z_ISREF_P(free_op_data)) {
46745 if (Z_REFCOUNTED_P(value)) {
46746 Z_ADDREF_P(value);
46747 }
46748 zval_ptr_dtor_nogc(free_op_data);
46749 }
46750 } else if (IS_TMP_VAR == IS_CONST) {
46751 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
46752 Z_ADDREF_P(value);
46753 }
46754 }
46755 } else {
46756 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46757 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46758 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46759 } else {
46760 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46761 }
46762 if (UNEXPECTED(variable_ptr == NULL)) {
46763 goto assign_dim_error;
46764 }
46765 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
46766 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
46767 }
46768 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46769 ZVAL_COPY(EX_VAR(opline->result.var), value);
46770 }
46771 if (garbage) {
46772 GC_DTOR_NO_REF(garbage);
46773 }
46774 } else {
46775 if (EXPECTED(Z_ISREF_P(object_ptr))) {
46776 object_ptr = Z_REFVAL_P(object_ptr);
46777 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46778 goto try_assign_dim_array;
46779 }
46780 }
46781 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
46782 zend_object *obj = Z_OBJ_P(object_ptr);
46783
46784 GC_ADDREF(obj);
46785 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46786 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
46787 dim = ZVAL_UNDEFINED_OP2();
46788 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46789 dim++;
46790 }
46791
46792 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
46793 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
46794 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46795 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
46796 ZVAL_DEREF(value);
46797 }
46798
46799 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
46800
46801 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46802 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
46803 zend_objects_store_del(obj);
46804 }
46805 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
46806 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46807 zend_use_new_element_for_string();
46808 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46809 UNDEF_RESULT();
46810 } else {
46811 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46812 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
46813 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
46814 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46815 }
46816 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
46817 if (Z_ISREF_P(orig_object_ptr)
46818 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
46819 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
46820 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46821 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46822 UNDEF_RESULT();
46823 } else {
46824 HashTable *ht = zend_new_array(8);
46825 uint8_t old_type = Z_TYPE_P(object_ptr);
46826
46827 ZVAL_ARR(object_ptr, ht);
46828 if (UNEXPECTED(old_type == IS_FALSE)) {
46829 GC_ADDREF(ht);
46830 zend_false_to_array_deprecated();
46831 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
46832 zend_array_destroy(ht);
46833 goto assign_dim_error;
46834 }
46835 }
46836 goto try_assign_dim_array;
46837 }
46838 } else {
46839 zend_use_scalar_as_array();
46840 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46841 assign_dim_error:
46842 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46843 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46844 ZVAL_NULL(EX_VAR(opline->result.var));
46845 }
46846 }
46847 }
46848 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
46849 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46850 }
46851
46852 /* assign_dim has two opcodes! */
46853 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46854 }
46855
ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46856 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46857 {
46858 USE_OPLINE
46859 zval *object_ptr, *orig_object_ptr;
46860 zval *value;
46861 zval *variable_ptr;
46862 zval *dim;
46863 zend_refcounted *garbage = NULL;
46864
46865 SAVE_OPLINE();
46866 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
46867
46868 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46869 try_assign_dim_array:
46870 SEPARATE_ARRAY(object_ptr);
46871 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46872 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
46873 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
46874 HashTable *ht = Z_ARRVAL_P(object_ptr);
46875 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
46876 GC_ADDREF(ht);
46877 }
46878 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46879 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
46880 zend_array_destroy(ht);
46881 goto assign_dim_error;
46882 }
46883 }
46884 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
46885 ZVAL_DEREF(value);
46886 }
46887 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
46888 if (UNEXPECTED(value == NULL)) {
46889 zend_cannot_add_element();
46890 goto assign_dim_error;
46891 } else if (IS_VAR == IS_CV) {
46892 if (Z_REFCOUNTED_P(value)) {
46893 Z_ADDREF_P(value);
46894 }
46895 } else if (IS_VAR == IS_VAR) {
46896 zval *free_op_data = EX_VAR((opline+1)->op1.var);
46897 if (Z_ISREF_P(free_op_data)) {
46898 if (Z_REFCOUNTED_P(value)) {
46899 Z_ADDREF_P(value);
46900 }
46901 zval_ptr_dtor_nogc(free_op_data);
46902 }
46903 } else if (IS_VAR == IS_CONST) {
46904 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
46905 Z_ADDREF_P(value);
46906 }
46907 }
46908 } else {
46909 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46910 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46911 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46912 } else {
46913 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46914 }
46915 if (UNEXPECTED(variable_ptr == NULL)) {
46916 goto assign_dim_error;
46917 }
46918 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
46919 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
46920 }
46921 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46922 ZVAL_COPY(EX_VAR(opline->result.var), value);
46923 }
46924 if (garbage) {
46925 GC_DTOR_NO_REF(garbage);
46926 }
46927 } else {
46928 if (EXPECTED(Z_ISREF_P(object_ptr))) {
46929 object_ptr = Z_REFVAL_P(object_ptr);
46930 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46931 goto try_assign_dim_array;
46932 }
46933 }
46934 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
46935 zend_object *obj = Z_OBJ_P(object_ptr);
46936
46937 GC_ADDREF(obj);
46938 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46939 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
46940 dim = ZVAL_UNDEFINED_OP2();
46941 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46942 dim++;
46943 }
46944
46945 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
46946 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
46947 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46948 } else if (IS_VAR & (IS_CV|IS_VAR)) {
46949 ZVAL_DEREF(value);
46950 }
46951
46952 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
46953
46954 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46955 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
46956 zend_objects_store_del(obj);
46957 }
46958 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
46959 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46960 zend_use_new_element_for_string();
46961 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46962 UNDEF_RESULT();
46963 } else {
46964 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46965 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
46966 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
46967 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46968 }
46969 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
46970 if (Z_ISREF_P(orig_object_ptr)
46971 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
46972 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
46973 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46974 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46975 UNDEF_RESULT();
46976 } else {
46977 HashTable *ht = zend_new_array(8);
46978 uint8_t old_type = Z_TYPE_P(object_ptr);
46979
46980 ZVAL_ARR(object_ptr, ht);
46981 if (UNEXPECTED(old_type == IS_FALSE)) {
46982 GC_ADDREF(ht);
46983 zend_false_to_array_deprecated();
46984 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
46985 zend_array_destroy(ht);
46986 goto assign_dim_error;
46987 }
46988 }
46989 goto try_assign_dim_array;
46990 }
46991 } else {
46992 zend_use_scalar_as_array();
46993 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46994 assign_dim_error:
46995 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46996 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46997 ZVAL_NULL(EX_VAR(opline->result.var));
46998 }
46999 }
47000 }
47001 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
47002 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47003 }
47004
47005 /* assign_dim has two opcodes! */
47006 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47007 }
47008
ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47009 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47010 {
47011 USE_OPLINE
47012 zval *object_ptr, *orig_object_ptr;
47013 zval *value;
47014 zval *variable_ptr;
47015 zval *dim;
47016 zend_refcounted *garbage = NULL;
47017
47018 SAVE_OPLINE();
47019 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
47020
47021 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
47022 try_assign_dim_array:
47023 SEPARATE_ARRAY(object_ptr);
47024 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
47025 value = EX_VAR((opline+1)->op1.var);
47026 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
47027 HashTable *ht = Z_ARRVAL_P(object_ptr);
47028 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
47029 GC_ADDREF(ht);
47030 }
47031 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
47032 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
47033 zend_array_destroy(ht);
47034 goto assign_dim_error;
47035 }
47036 }
47037 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
47038 ZVAL_DEREF(value);
47039 }
47040 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
47041 if (UNEXPECTED(value == NULL)) {
47042 zend_cannot_add_element();
47043 goto assign_dim_error;
47044 } else if (IS_CV == IS_CV) {
47045 if (Z_REFCOUNTED_P(value)) {
47046 Z_ADDREF_P(value);
47047 }
47048 } else if (IS_CV == IS_VAR) {
47049 zval *free_op_data = EX_VAR((opline+1)->op1.var);
47050 if (Z_ISREF_P(free_op_data)) {
47051 if (Z_REFCOUNTED_P(value)) {
47052 Z_ADDREF_P(value);
47053 }
47054 zval_ptr_dtor_nogc(free_op_data);
47055 }
47056 } else if (IS_CV == IS_CONST) {
47057 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
47058 Z_ADDREF_P(value);
47059 }
47060 }
47061 } else {
47062 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47063 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47064 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
47065 } else {
47066 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
47067 }
47068 if (UNEXPECTED(variable_ptr == NULL)) {
47069 goto assign_dim_error;
47070 }
47071 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
47072 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
47073 }
47074 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47075 ZVAL_COPY(EX_VAR(opline->result.var), value);
47076 }
47077 if (garbage) {
47078 GC_DTOR_NO_REF(garbage);
47079 }
47080 } else {
47081 if (EXPECTED(Z_ISREF_P(object_ptr))) {
47082 object_ptr = Z_REFVAL_P(object_ptr);
47083 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
47084 goto try_assign_dim_array;
47085 }
47086 }
47087 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
47088 zend_object *obj = Z_OBJ_P(object_ptr);
47089
47090 GC_ADDREF(obj);
47091 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47092 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
47093 dim = ZVAL_UNDEFINED_OP2();
47094 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
47095 dim++;
47096 }
47097
47098 value = EX_VAR((opline+1)->op1.var);
47099 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
47100 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
47101 } else if (IS_CV & (IS_CV|IS_VAR)) {
47102 ZVAL_DEREF(value);
47103 }
47104
47105 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
47106
47107 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
47108 zend_objects_store_del(obj);
47109 }
47110 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
47111 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
47112 zend_use_new_element_for_string();
47113
47114 UNDEF_RESULT();
47115 } else {
47116 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47117 value = EX_VAR((opline+1)->op1.var);
47118 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
47119
47120 }
47121 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
47122 if (Z_ISREF_P(orig_object_ptr)
47123 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
47124 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
47125 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47126
47127 UNDEF_RESULT();
47128 } else {
47129 HashTable *ht = zend_new_array(8);
47130 uint8_t old_type = Z_TYPE_P(object_ptr);
47131
47132 ZVAL_ARR(object_ptr, ht);
47133 if (UNEXPECTED(old_type == IS_FALSE)) {
47134 GC_ADDREF(ht);
47135 zend_false_to_array_deprecated();
47136 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
47137 zend_array_destroy(ht);
47138 goto assign_dim_error;
47139 }
47140 }
47141 goto try_assign_dim_array;
47142 }
47143 } else {
47144 zend_use_scalar_as_array();
47145 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47146 assign_dim_error:
47147
47148 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47149 ZVAL_NULL(EX_VAR(opline->result.var));
47150 }
47151 }
47152 }
47153 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
47154 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47155 }
47156
47157 /* assign_dim has two opcodes! */
47158 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47159 }
47160
ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47161 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47162 {
47163 USE_OPLINE
47164 zval *property, *container, *value_ptr;
47165
47166 SAVE_OPLINE();
47167
47168 container = EX_VAR(opline->op1.var);
47169 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47170
47171 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
47172
47173 if (1) {
47174 if (IS_CV == IS_UNUSED) {
47175 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47176 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47177 } else {
47178 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47179 }
47180 } else {
47181 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47182 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47183 } else {
47184 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47185 }
47186 }
47187 } else {
47188 zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
47189 }
47190
47191 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47192 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47193 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47194 }
47195
47196 /* 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)47197 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47198 {
47199 USE_OPLINE
47200 zval *property, *container, *value_ptr;
47201
47202 SAVE_OPLINE();
47203
47204 container = EX_VAR(opline->op1.var);
47205 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47206
47207 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
47208
47209 if (1) {
47210 if (IS_CV == IS_UNUSED) {
47211 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47212 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47213 } else {
47214 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47215 }
47216 } else {
47217 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47218 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47219 } else {
47220 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47221 }
47222 }
47223 } else {
47224 zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
47225 }
47226
47227 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47228
47229 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47230 }
47231
47232 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47233 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47234 {
47235 USE_OPLINE
47236 zval *op1, *op2;
47237 zend_string *op1_str, *op2_str, *str;
47238
47239
47240 op1 = EX_VAR(opline->op1.var);
47241 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47242 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
47243 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
47244 zend_string *op1_str = Z_STR_P(op1);
47245 zend_string *op2_str = Z_STR_P(op2);
47246 zend_string *str;
47247 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
47248
47249 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
47250 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
47251 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
47252 } else {
47253 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
47254 }
47255 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
47256 zend_string_release_ex(op1_str, 0);
47257 }
47258 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
47259 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
47260 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
47261 } else {
47262 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
47263 }
47264 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
47265 zend_string_release_ex(op2_str, 0);
47266 }
47267 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
47268 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
47269 size_t len = ZSTR_LEN(op1_str);
47270
47271 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
47272 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
47273 GC_ADD_FLAGS(str, flags);
47274 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
47275 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
47276 zend_string_release_ex(op2_str, 0);
47277 }
47278 } else {
47279 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
47280 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
47281 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
47282 GC_ADD_FLAGS(str, flags);
47283 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
47284 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
47285 zend_string_release_ex(op1_str, 0);
47286 }
47287 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
47288 zend_string_release_ex(op2_str, 0);
47289 }
47290 }
47291 ZEND_VM_NEXT_OPCODE();
47292 }
47293
47294 SAVE_OPLINE();
47295 if (IS_CV == IS_CONST) {
47296 op1_str = Z_STR_P(op1);
47297 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
47298 op1_str = zend_string_copy(Z_STR_P(op1));
47299 } else {
47300 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
47301 ZVAL_UNDEFINED_OP1();
47302 }
47303 op1_str = zval_get_string_func(op1);
47304 }
47305 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47306 op2_str = Z_STR_P(op2);
47307 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
47308 op2_str = zend_string_copy(Z_STR_P(op2));
47309 } else {
47310 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
47311 ZVAL_UNDEFINED_OP2();
47312 }
47313 op2_str = zval_get_string_func(op2);
47314 }
47315 do {
47316 if (IS_CV != IS_CONST) {
47317 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
47318 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47319 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
47320 GC_ADDREF(op2_str);
47321 }
47322 }
47323 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
47324 zend_string_release_ex(op1_str, 0);
47325 break;
47326 }
47327 }
47328 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47329 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
47330 if (IS_CV == IS_CONST) {
47331 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
47332 GC_ADDREF(op1_str);
47333 }
47334 }
47335 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
47336 zend_string_release_ex(op2_str, 0);
47337 break;
47338 }
47339 }
47340 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
47341 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
47342 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
47343
47344 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
47345 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
47346 if (IS_CV != IS_CONST) {
47347 zend_string_release_ex(op1_str, 0);
47348 }
47349 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47350 zend_string_release_ex(op2_str, 0);
47351 }
47352 } while (0);
47353
47354 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47355 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47356 }
47357
ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47358 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47359 {
47360 USE_OPLINE
47361 zval *function_name;
47362 zval *object;
47363 zend_function *fbc;
47364 zend_class_entry *called_scope;
47365 zend_object *obj;
47366 zend_execute_data *call;
47367 uint32_t call_info;
47368
47369 SAVE_OPLINE();
47370
47371 object = EX_VAR(opline->op1.var);
47372
47373 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47374 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47375 }
47376
47377 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
47378 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
47379 do {
47380 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
47381 function_name = Z_REFVAL_P(function_name);
47382 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
47383 break;
47384 }
47385 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
47386 ZVAL_UNDEFINED_OP2();
47387 if (UNEXPECTED(EG(exception) != NULL)) {
47388
47389 HANDLE_EXCEPTION();
47390 }
47391 }
47392 zend_throw_error(NULL, "Method name must be a string");
47393 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47394
47395 HANDLE_EXCEPTION();
47396 } while (0);
47397 }
47398
47399 if (IS_CV == IS_UNUSED) {
47400 obj = Z_OBJ_P(object);
47401 } else {
47402 do {
47403 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
47404 obj = Z_OBJ_P(object);
47405 } else {
47406 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
47407 zend_reference *ref = Z_REF_P(object);
47408
47409 object = &ref->val;
47410 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
47411 obj = Z_OBJ_P(object);
47412 if (IS_CV & IS_VAR) {
47413 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
47414 efree_size(ref, sizeof(zend_reference));
47415 } else {
47416 Z_ADDREF_P(object);
47417 }
47418 }
47419 break;
47420 }
47421 }
47422 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
47423 object = ZVAL_UNDEFINED_OP1();
47424 if (UNEXPECTED(EG(exception) != NULL)) {
47425 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47426 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47427 }
47428 HANDLE_EXCEPTION();
47429 }
47430 }
47431 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47432 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47433 }
47434 zend_invalid_method_call(object, function_name);
47435 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47436
47437 HANDLE_EXCEPTION();
47438 }
47439 } while (0);
47440 }
47441
47442 called_scope = obj->ce;
47443
47444 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
47445 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
47446 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
47447 } else {
47448 zend_object *orig_obj = obj;
47449
47450 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47451 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47452 }
47453
47454 /* First, locate the function. */
47455 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));
47456 if (UNEXPECTED(fbc == NULL)) {
47457 if (EXPECTED(!EG(exception))) {
47458 zend_undefined_method(obj->ce, Z_STR_P(function_name));
47459 }
47460 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47461 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
47462 zend_objects_store_del(orig_obj);
47463 }
47464 HANDLE_EXCEPTION();
47465 }
47466 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
47467 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
47468 EXPECTED(obj == orig_obj)) {
47469 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
47470 }
47471 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
47472 GC_ADDREF(obj); /* For $this pointer */
47473 if (GC_DELREF(orig_obj) == 0) {
47474 zend_objects_store_del(orig_obj);
47475 }
47476 }
47477 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
47478 init_func_run_time_cache(&fbc->op_array);
47479 }
47480 }
47481
47482 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47483 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47484 }
47485
47486 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
47487 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
47488 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
47489 zend_objects_store_del(obj);
47490 if (UNEXPECTED(EG(exception))) {
47491 HANDLE_EXCEPTION();
47492 }
47493 }
47494 /* call static method */
47495 obj = (zend_object*)called_scope;
47496 call_info = ZEND_CALL_NESTED_FUNCTION;
47497 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
47498 if (IS_CV == IS_CV) {
47499 GC_ADDREF(obj); /* For $this pointer */
47500 }
47501 /* CV may be changed indirectly (e.g. when it's a reference) */
47502 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
47503 }
47504
47505 call = zend_vm_stack_push_call_frame(call_info,
47506 fbc, opline->extended_value, obj);
47507 call->prev_execute_data = EX(call);
47508 EX(call) = call;
47509
47510 ZEND_VM_NEXT_OPCODE();
47511 }
47512
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47513 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47514 {
47515 USE_OPLINE
47516 zval *expr_ptr, new_expr;
47517
47518 SAVE_OPLINE();
47519 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
47520 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
47521 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
47522 if (Z_ISREF_P(expr_ptr)) {
47523 Z_ADDREF_P(expr_ptr);
47524 } else {
47525 ZVAL_MAKE_REF_EX(expr_ptr, 2);
47526 }
47527
47528 } else {
47529 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
47530 if (IS_CV == IS_TMP_VAR) {
47531 /* pass */
47532 } else if (IS_CV == IS_CONST) {
47533 Z_TRY_ADDREF_P(expr_ptr);
47534 } else if (IS_CV == IS_CV) {
47535 ZVAL_DEREF(expr_ptr);
47536 Z_TRY_ADDREF_P(expr_ptr);
47537 } else /* if (IS_CV == IS_VAR) */ {
47538 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
47539 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
47540
47541 expr_ptr = Z_REFVAL_P(expr_ptr);
47542 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
47543 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
47544 expr_ptr = &new_expr;
47545 efree_size(ref, sizeof(zend_reference));
47546 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
47547 Z_ADDREF_P(expr_ptr);
47548 }
47549 }
47550 }
47551 }
47552
47553 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
47554 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47555 zend_string *str;
47556 zend_ulong hval;
47557
47558 add_again:
47559 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
47560 str = Z_STR_P(offset);
47561 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47562 if (ZEND_HANDLE_NUMERIC(str, hval)) {
47563 goto num_index;
47564 }
47565 }
47566 str_index:
47567 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
47568 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
47569 hval = Z_LVAL_P(offset);
47570 num_index:
47571 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
47572 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
47573 offset = Z_REFVAL_P(offset);
47574 goto add_again;
47575 } else if (Z_TYPE_P(offset) == IS_NULL) {
47576 str = ZSTR_EMPTY_ALLOC();
47577 goto str_index;
47578 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
47579 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
47580 goto num_index;
47581 } else if (Z_TYPE_P(offset) == IS_FALSE) {
47582 hval = 0;
47583 goto num_index;
47584 } else if (Z_TYPE_P(offset) == IS_TRUE) {
47585 hval = 1;
47586 goto num_index;
47587 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
47588 zend_use_resource_as_offset(offset);
47589 hval = Z_RES_HANDLE_P(offset);
47590 goto num_index;
47591 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
47592 ZVAL_UNDEFINED_OP2();
47593 str = ZSTR_EMPTY_ALLOC();
47594 goto str_index;
47595 } else {
47596 zend_illegal_array_offset_access(offset);
47597 zval_ptr_dtor_nogc(expr_ptr);
47598 }
47599 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47600 } else {
47601 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
47602 zend_cannot_add_element();
47603 zval_ptr_dtor_nogc(expr_ptr);
47604 }
47605 }
47606 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47607 }
47608
ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47609 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47610 {
47611 zval *array;
47612 uint32_t size;
47613 USE_OPLINE
47614
47615 array = EX_VAR(opline->result.var);
47616 if (IS_CV != IS_UNUSED) {
47617 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
47618 ZVAL_ARR(array, zend_new_array(size));
47619 /* Explicitly initialize array as not-packed if flag is set */
47620 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
47621 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
47622 }
47623 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47624 } else {
47625 ZVAL_ARR(array, zend_new_array(0));
47626 ZEND_VM_NEXT_OPCODE();
47627 }
47628 }
47629
ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47630 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47631 {
47632 USE_OPLINE
47633 zval *container;
47634 zval *offset;
47635 zend_ulong hval;
47636 zend_string *key;
47637
47638 SAVE_OPLINE();
47639 container = EX_VAR(opline->op1.var);
47640 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47641
47642 do {
47643 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
47644 HashTable *ht;
47645
47646 unset_dim_array:
47647 SEPARATE_ARRAY(container);
47648 ht = Z_ARRVAL_P(container);
47649 offset_again:
47650 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
47651 key = Z_STR_P(offset);
47652 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47653 if (ZEND_HANDLE_NUMERIC(key, hval)) {
47654 goto num_index_dim;
47655 }
47656 }
47657 str_index_dim:
47658 ZEND_ASSERT(ht != &EG(symbol_table));
47659 zend_hash_del(ht, key);
47660 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
47661 hval = Z_LVAL_P(offset);
47662 num_index_dim:
47663 zend_hash_index_del(ht, hval);
47664 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
47665 offset = Z_REFVAL_P(offset);
47666 goto offset_again;
47667 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
47668 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
47669 goto num_index_dim;
47670 } else if (Z_TYPE_P(offset) == IS_NULL) {
47671 key = ZSTR_EMPTY_ALLOC();
47672 goto str_index_dim;
47673 } else if (Z_TYPE_P(offset) == IS_FALSE) {
47674 hval = 0;
47675 goto num_index_dim;
47676 } else if (Z_TYPE_P(offset) == IS_TRUE) {
47677 hval = 1;
47678 goto num_index_dim;
47679 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
47680 zend_use_resource_as_offset(offset);
47681 hval = Z_RES_HANDLE_P(offset);
47682 goto num_index_dim;
47683 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
47684 ZVAL_UNDEFINED_OP2();
47685 key = ZSTR_EMPTY_ALLOC();
47686 goto str_index_dim;
47687 } else {
47688 zend_illegal_array_offset_unset(offset);
47689 }
47690 break;
47691 } else if (Z_ISREF_P(container)) {
47692 container = Z_REFVAL_P(container);
47693 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
47694 goto unset_dim_array;
47695 }
47696 }
47697 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
47698 container = ZVAL_UNDEFINED_OP1();
47699 }
47700 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
47701 offset = ZVAL_UNDEFINED_OP2();
47702 }
47703 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
47704 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
47705 offset++;
47706 }
47707 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
47708 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
47709 zend_throw_error(NULL, "Cannot unset string offsets");
47710 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
47711 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
47712 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
47713 zend_false_to_array_deprecated();
47714 }
47715 } while (0);
47716
47717 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47718
47719 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47720 }
47721
ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47722 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47723 {
47724 USE_OPLINE
47725 zval *container;
47726 zval *offset;
47727 zend_string *name, *tmp_name;
47728
47729 SAVE_OPLINE();
47730 container = EX_VAR(opline->op1.var);
47731 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47732
47733 do {
47734 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
47735 if (Z_ISREF_P(container)) {
47736 container = Z_REFVAL_P(container);
47737 if (Z_TYPE_P(container) != IS_OBJECT) {
47738 if (IS_CV == IS_CV
47739 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
47740 ZVAL_UNDEFINED_OP1();
47741 }
47742 break;
47743 }
47744 } else {
47745 break;
47746 }
47747 }
47748 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47749 name = Z_STR_P(offset);
47750 } else {
47751 name = zval_try_get_tmp_string(offset, &tmp_name);
47752 if (UNEXPECTED(!name)) {
47753 break;
47754 }
47755 }
47756 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));
47757 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47758 zend_tmp_string_release(tmp_name);
47759 }
47760 } while (0);
47761
47762 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47763
47764 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47765 }
47766
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47767 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47768 {
47769 USE_OPLINE
47770 zval *container;
47771 bool result;
47772 zend_ulong hval;
47773 zval *offset;
47774
47775 SAVE_OPLINE();
47776 container = EX_VAR(opline->op1.var);
47777 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47778
47779 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
47780 HashTable *ht;
47781 zval *value;
47782 zend_string *str;
47783
47784 isset_dim_obj_array:
47785 ht = Z_ARRVAL_P(container);
47786 isset_again:
47787 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
47788 str = Z_STR_P(offset);
47789 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47790 if (ZEND_HANDLE_NUMERIC(str, hval)) {
47791 goto num_index_prop;
47792 }
47793 }
47794 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
47795 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
47796 hval = Z_LVAL_P(offset);
47797 num_index_prop:
47798 value = zend_hash_index_find(ht, hval);
47799 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
47800 offset = Z_REFVAL_P(offset);
47801 goto isset_again;
47802 } else {
47803 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
47804 if (UNEXPECTED(EG(exception))) {
47805 result = 0;
47806 goto isset_dim_obj_exit;
47807 }
47808 }
47809
47810 if (!(opline->extended_value & ZEND_ISEMPTY)) {
47811 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
47812 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
47813 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
47814
47815 if (IS_CV & (IS_CONST|IS_CV)) {
47816 /* avoid exception check */
47817 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47818 ZEND_VM_SMART_BRANCH(result, 0);
47819 }
47820 } else {
47821 result = (value == NULL || !i_zend_is_true(value));
47822 }
47823 goto isset_dim_obj_exit;
47824 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
47825 container = Z_REFVAL_P(container);
47826 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
47827 goto isset_dim_obj_array;
47828 }
47829 }
47830
47831 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
47832 offset++;
47833 }
47834 if (!(opline->extended_value & ZEND_ISEMPTY)) {
47835 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
47836 } else {
47837 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
47838 }
47839
47840 isset_dim_obj_exit:
47841 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47842
47843 ZEND_VM_SMART_BRANCH(result, 1);
47844 }
47845
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47846 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47847 {
47848 USE_OPLINE
47849 zval *container;
47850 int result;
47851 zval *offset;
47852 zend_string *name, *tmp_name;
47853
47854 SAVE_OPLINE();
47855 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
47856 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47857
47858 if (IS_CV == IS_CONST ||
47859 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
47860 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
47861 container = Z_REFVAL_P(container);
47862 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
47863 result = (opline->extended_value & ZEND_ISEMPTY);
47864 goto isset_object_finish;
47865 }
47866 } else {
47867 result = (opline->extended_value & ZEND_ISEMPTY);
47868 goto isset_object_finish;
47869 }
47870 }
47871
47872 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47873 name = Z_STR_P(offset);
47874 } else {
47875 name = zval_try_get_tmp_string(offset, &tmp_name);
47876 if (UNEXPECTED(!name)) {
47877 result = 0;
47878 goto isset_object_finish;
47879 }
47880 }
47881
47882 result =
47883 (opline->extended_value & ZEND_ISEMPTY) ^
47884 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));
47885
47886 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47887 zend_tmp_string_release(tmp_name);
47888 }
47889
47890 isset_object_finish:
47891 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47892
47893 ZEND_VM_SMART_BRANCH(result, 1);
47894 }
47895
ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47896 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47897 {
47898 USE_OPLINE
47899
47900 zval *key, *subject;
47901 HashTable *ht;
47902 bool result;
47903
47904 SAVE_OPLINE();
47905
47906 key = EX_VAR(opline->op1.var);
47907 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47908
47909 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
47910 array_key_exists_array:
47911 ht = Z_ARRVAL_P(subject);
47912 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
47913 } else {
47914 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
47915 subject = Z_REFVAL_P(subject);
47916 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
47917 goto array_key_exists_array;
47918 }
47919 }
47920 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
47921 result = 0;
47922 }
47923
47924 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47925
47926 ZEND_VM_SMART_BRANCH(result, 1);
47927 }
47928
47929 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47930 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47931 {
47932 USE_OPLINE
47933
47934 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
47935
47936 SAVE_OPLINE();
47937 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
47938 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47939 }
47940
47941 /* Destroy the previously yielded value */
47942 zval_ptr_dtor(&generator->value);
47943
47944 /* Destroy the previously yielded key */
47945 zval_ptr_dtor(&generator->key);
47946
47947 /* Set the new yielded value */
47948 if (IS_CV != IS_UNUSED) {
47949 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
47950 /* Constants and temporary variables aren't yieldable by reference,
47951 * but we still allow them with a notice. */
47952 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
47953 zval *value;
47954
47955 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
47956
47957 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
47958 ZVAL_COPY_VALUE(&generator->value, value);
47959 if (IS_CV == IS_CONST) {
47960 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
47961 Z_ADDREF(generator->value);
47962 }
47963 }
47964 } else {
47965 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
47966
47967 /* If a function call result is yielded and the function did
47968 * not return by reference we throw a notice. */
47969 do {
47970 if (IS_CV == IS_VAR) {
47971 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
47972 if (opline->extended_value == ZEND_RETURNS_FUNCTION
47973 && !Z_ISREF_P(value_ptr)) {
47974 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
47975 ZVAL_COPY(&generator->value, value_ptr);
47976 break;
47977 }
47978 }
47979 if (Z_ISREF_P(value_ptr)) {
47980 Z_ADDREF_P(value_ptr);
47981 } else {
47982 ZVAL_MAKE_REF_EX(value_ptr, 2);
47983 }
47984 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
47985 } while (0);
47986
47987 }
47988 } else {
47989 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
47990
47991 /* Consts, temporary variables and references need copying */
47992 if (IS_CV == IS_CONST) {
47993 ZVAL_COPY_VALUE(&generator->value, value);
47994 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
47995 Z_ADDREF(generator->value);
47996 }
47997 } else if (IS_CV == IS_TMP_VAR) {
47998 ZVAL_COPY_VALUE(&generator->value, value);
47999 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
48000 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
48001
48002 } else {
48003 ZVAL_COPY_VALUE(&generator->value, value);
48004 if (IS_CV == IS_CV) {
48005 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
48006 }
48007 }
48008 }
48009 } else {
48010 /* If no value was specified yield null */
48011 ZVAL_NULL(&generator->value);
48012 }
48013
48014 /* Set the new yielded key */
48015 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48016 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48017 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
48018 key = Z_REFVAL_P(key);
48019 }
48020 ZVAL_COPY(&generator->key, key);
48021 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48022
48023 if (Z_TYPE(generator->key) == IS_LONG
48024 && Z_LVAL(generator->key) > generator->largest_used_integer_key
48025 ) {
48026 generator->largest_used_integer_key = Z_LVAL(generator->key);
48027 }
48028 } else {
48029 /* If no key was specified we use auto-increment keys */
48030 generator->largest_used_integer_key++;
48031 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
48032 }
48033
48034 if (RETURN_VALUE_USED(opline)) {
48035 /* If the return value of yield is used set the send
48036 * target and initialize it to NULL */
48037 generator->send_target = EX_VAR(opline->result.var);
48038 ZVAL_NULL(generator->send_target);
48039 } else {
48040 generator->send_target = NULL;
48041 }
48042
48043 /* We increment to the next op, so we are at the correct position when the
48044 * generator is resumed. */
48045 ZEND_VM_INC_OPCODE();
48046
48047 /* The GOTO VM uses a local opline variable. We need to set the opline
48048 * variable in execute_data so we don't resume at an old position. */
48049 SAVE_OPLINE();
48050
48051 ZEND_VM_RETURN();
48052 }
48053
ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48054 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48055 {
48056 USE_OPLINE
48057 zval *op1, *op2;
48058 bool result;
48059
48060 SAVE_OPLINE();
48061 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48062 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
48063 result = fast_is_identical_function(op1, op2);
48064
48065 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48066 ZEND_VM_SMART_BRANCH(result, 1);
48067 }
48068
ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48069 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48070 {
48071 USE_OPLINE
48072 zval *op1, *op2;
48073 bool result;
48074
48075 SAVE_OPLINE();
48076 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48077 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
48078 result = fast_is_not_identical_function(op1, op2);
48079
48080 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48081 ZEND_VM_SMART_BRANCH(result, 1);
48082 }
48083
ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48084 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48085 {
48086 USE_OPLINE
48087 zval *value;
48088 zval *variable_ptr;
48089
48090 SAVE_OPLINE();
48091 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
48092 variable_ptr = EX_VAR(opline->op1.var);
48093
48094 if (0 || UNEXPECTED(0)) {
48095 zend_refcounted *garbage = NULL;
48096
48097 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
48098 if (UNEXPECTED(0)) {
48099 ZVAL_COPY(EX_VAR(opline->result.var), value);
48100 }
48101 if (garbage) {
48102 GC_DTOR_NO_REF(garbage);
48103 }
48104 } else {
48105 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
48106 }
48107
48108 /* zend_assign_to_variable() always takes care of op2, never free it! */
48109
48110 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48111 }
48112
ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48113 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48114 {
48115 USE_OPLINE
48116 zval *value;
48117 zval *variable_ptr;
48118
48119 SAVE_OPLINE();
48120 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
48121 variable_ptr = EX_VAR(opline->op1.var);
48122
48123 if (0 || UNEXPECTED(1)) {
48124 zend_refcounted *garbage = NULL;
48125
48126 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
48127 if (UNEXPECTED(1)) {
48128 ZVAL_COPY(EX_VAR(opline->result.var), value);
48129 }
48130 if (garbage) {
48131 GC_DTOR_NO_REF(garbage);
48132 }
48133 } else {
48134 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
48135 }
48136
48137 /* zend_assign_to_variable() always takes care of op2, never free it! */
48138
48139 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48140 }
48141
ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48142 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48143 {
48144 USE_OPLINE
48145 zval *op1, *op2;
48146 bool result;
48147
48148 SAVE_OPLINE();
48149 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48150 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
48151 result = fast_is_identical_function(op1, op2);
48152
48153 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48154 ZEND_VM_SMART_BRANCH(result, 1);
48155 }
48156
ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48157 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48158 {
48159 USE_OPLINE
48160 zval *op1, *op2;
48161 bool result;
48162
48163 SAVE_OPLINE();
48164 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48165 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
48166 result = fast_is_not_identical_function(op1, op2);
48167
48168 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48169 ZEND_VM_SMART_BRANCH(result, 1);
48170 }
48171
ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48172 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48173 {
48174 USE_OPLINE
48175 zval *value;
48176 zval *variable_ptr;
48177
48178 SAVE_OPLINE();
48179 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48180 variable_ptr = EX_VAR(opline->op1.var);
48181
48182 if (0 || UNEXPECTED(0)) {
48183 zend_refcounted *garbage = NULL;
48184
48185 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
48186 if (UNEXPECTED(0)) {
48187 ZVAL_COPY(EX_VAR(opline->result.var), value);
48188 }
48189 if (garbage) {
48190 GC_DTOR_NO_REF(garbage);
48191 }
48192 } else {
48193 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
48194 }
48195
48196 /* zend_assign_to_variable() always takes care of op2, never free it! */
48197
48198 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48199 }
48200
ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48201 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48202 {
48203 USE_OPLINE
48204 zval *value;
48205 zval *variable_ptr;
48206
48207 SAVE_OPLINE();
48208 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48209 variable_ptr = EX_VAR(opline->op1.var);
48210
48211 if (0 || UNEXPECTED(1)) {
48212 zend_refcounted *garbage = NULL;
48213
48214 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
48215 if (UNEXPECTED(1)) {
48216 ZVAL_COPY(EX_VAR(opline->result.var), value);
48217 }
48218 if (garbage) {
48219 GC_DTOR_NO_REF(garbage);
48220 }
48221 } else {
48222 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
48223 }
48224
48225 /* zend_assign_to_variable() always takes care of op2, never free it! */
48226
48227 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48228 }
48229
ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48230 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48231 {
48232 USE_OPLINE
48233 zval *variable_ptr;
48234 zval *value_ptr;
48235 zend_refcounted *garbage = NULL;
48236
48237 SAVE_OPLINE();
48238 value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48239 variable_ptr = EX_VAR(opline->op1.var);
48240
48241 if (IS_CV == IS_VAR &&
48242 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
48243
48244 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
48245 variable_ptr = &EG(uninitialized_zval);
48246 } else if (IS_VAR == IS_VAR &&
48247 opline->extended_value == ZEND_RETURNS_FUNCTION &&
48248 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
48249
48250 variable_ptr = zend_wrong_assign_to_variable_reference(
48251 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
48252 } else {
48253 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
48254 }
48255
48256 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48257 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
48258 }
48259
48260 if (garbage) {
48261 GC_DTOR(garbage);
48262 }
48263
48264 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48265
48266 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48267 }
48268
ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48269 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48270 {
48271 USE_OPLINE
48272 zval *expr;
48273 bool result;
48274
48275 SAVE_OPLINE();
48276 expr = EX_VAR(opline->op1.var);
48277
48278 try_instanceof:
48279 if (Z_TYPE_P(expr) == IS_OBJECT) {
48280 zend_class_entry *ce;
48281
48282 if (IS_VAR == IS_CONST) {
48283 ce = CACHED_PTR(opline->extended_value);
48284 if (UNEXPECTED(ce == NULL)) {
48285 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);
48286 if (EXPECTED(ce)) {
48287 CACHE_PTR(opline->extended_value, ce);
48288 }
48289 }
48290 } else if (IS_VAR == IS_UNUSED) {
48291 ce = zend_fetch_class(NULL, opline->op2.num);
48292 if (UNEXPECTED(ce == NULL)) {
48293
48294 ZVAL_UNDEF(EX_VAR(opline->result.var));
48295 HANDLE_EXCEPTION();
48296 }
48297 } else {
48298 ce = Z_CE_P(EX_VAR(opline->op2.var));
48299 }
48300 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
48301 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
48302 expr = Z_REFVAL_P(expr);
48303 goto try_instanceof;
48304 } else {
48305 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
48306 ZVAL_UNDEFINED_OP1();
48307 }
48308 result = 0;
48309 }
48310
48311 ZEND_VM_SMART_BRANCH(result, 1);
48312 }
48313
ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48314 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48315 {
48316 USE_OPLINE
48317 zval *var_ptr;
48318 zval *value, *container, *dim;
48319 HashTable *ht;
48320
48321 SAVE_OPLINE();
48322 container = EX_VAR(opline->op1.var);
48323
48324 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
48325 assign_dim_op_array:
48326 SEPARATE_ARRAY(container);
48327 ht = Z_ARRVAL_P(container);
48328 assign_dim_op_new_array:
48329 dim = NULL;
48330 if (IS_UNUSED == IS_UNUSED) {
48331 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
48332 if (UNEXPECTED(!var_ptr)) {
48333 zend_cannot_add_element();
48334 goto assign_dim_op_ret_null;
48335 }
48336 } else {
48337 if (IS_UNUSED == IS_CONST) {
48338 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
48339 } else {
48340 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
48341 }
48342 if (UNEXPECTED(!var_ptr)) {
48343 goto assign_dim_op_ret_null;
48344 }
48345 }
48346
48347 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
48348
48349 do {
48350 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
48351 zend_reference *ref = Z_REF_P(var_ptr);
48352 var_ptr = Z_REFVAL_P(var_ptr);
48353 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
48354 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
48355 break;
48356 }
48357 }
48358 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
48359 } while (0);
48360
48361 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48362 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
48363 }
48364 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
48365 } else {
48366 if (EXPECTED(Z_ISREF_P(container))) {
48367 container = Z_REFVAL_P(container);
48368 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
48369 goto assign_dim_op_array;
48370 }
48371 }
48372
48373 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
48374 zend_object *obj = Z_OBJ_P(container);
48375
48376 dim = NULL;
48377 if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48378 dim++;
48379 }
48380 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
48381 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
48382 uint8_t old_type;
48383
48384 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
48385 ZVAL_UNDEFINED_OP1();
48386 }
48387 ht = zend_new_array(8);
48388 old_type = Z_TYPE_P(container);
48389 ZVAL_ARR(container, ht);
48390 if (UNEXPECTED(old_type == IS_FALSE)) {
48391 GC_ADDREF(ht);
48392 zend_false_to_array_deprecated();
48393 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48394 zend_array_destroy(ht);
48395 goto assign_dim_op_ret_null;
48396 }
48397 }
48398 goto assign_dim_op_new_array;
48399 } else {
48400 dim = NULL;
48401 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
48402 assign_dim_op_ret_null:
48403 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
48404 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48405 ZVAL_NULL(EX_VAR(opline->result.var));
48406 }
48407 }
48408 }
48409
48410
48411 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48412 }
48413
zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)48414 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)
48415 {
48416 USE_OPLINE
48417 zval *varname;
48418 zval *retval;
48419 zend_string *name, *tmp_name;
48420 HashTable *target_symbol_table;
48421
48422 SAVE_OPLINE();
48423 varname = EX_VAR(opline->op1.var);
48424
48425 if (IS_CV == IS_CONST) {
48426 name = Z_STR_P(varname);
48427 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
48428 name = Z_STR_P(varname);
48429 tmp_name = NULL;
48430 } else {
48431 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
48432 ZVAL_UNDEFINED_OP1();
48433 }
48434 name = zval_try_get_tmp_string(varname, &tmp_name);
48435 if (UNEXPECTED(!name)) {
48436 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
48437
48438 }
48439 ZVAL_UNDEF(EX_VAR(opline->result.var));
48440 HANDLE_EXCEPTION();
48441 }
48442 }
48443
48444 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
48445 retval = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
48446 if (retval == NULL) {
48447 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
48448 fetch_this:
48449 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
48450 if (IS_CV != IS_CONST) {
48451 zend_tmp_string_release(tmp_name);
48452 }
48453 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48454 }
48455 if (type == BP_VAR_W) {
48456 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
48457 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
48458 retval = &EG(uninitialized_zval);
48459 } else {
48460 if (IS_CV == IS_CV) {
48461 /* Keep name alive in case an error handler tries to free it. */
48462 zend_string_addref(name);
48463 }
48464 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
48465 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
48466 if (type == BP_VAR_RW && !EG(exception)) {
48467 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
48468 } else {
48469 retval = &EG(uninitialized_zval);
48470 }
48471 if (IS_CV == IS_CV) {
48472 zend_string_release(name);
48473 }
48474 }
48475 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
48476 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
48477 retval = Z_INDIRECT_P(retval);
48478 if (Z_TYPE_P(retval) == IS_UNDEF) {
48479 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
48480 goto fetch_this;
48481 }
48482 if (type == BP_VAR_W) {
48483 ZVAL_NULL(retval);
48484 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
48485 retval = &EG(uninitialized_zval);
48486 } else {
48487 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
48488 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
48489 if (type == BP_VAR_RW && !EG(exception)) {
48490 ZVAL_NULL(retval);
48491 } else {
48492 retval = &EG(uninitialized_zval);
48493 }
48494 }
48495 }
48496 }
48497
48498 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
48499
48500 }
48501
48502 if (IS_CV != IS_CONST) {
48503 zend_tmp_string_release(tmp_name);
48504 }
48505
48506 ZEND_ASSERT(retval != NULL);
48507 if (type == BP_VAR_R || type == BP_VAR_IS) {
48508 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
48509 } else {
48510 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
48511 }
48512 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48513 }
48514
ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48515 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48516 {
48517 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48518 }
48519
ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48520 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48521 {
48522 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48523 }
48524
ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48525 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48526 {
48527 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48528 }
48529
ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48530 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48531 {
48532 int fetch_type =
48533 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
48534 BP_VAR_W : BP_VAR_R;
48535 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48536 }
48537
ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48538 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48539 {
48540 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48541 }
48542
ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48543 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48544 {
48545 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48546 }
48547
48548 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48549 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48550 {
48551 USE_OPLINE
48552 zval *container;
48553
48554 SAVE_OPLINE();
48555 container = EX_VAR(opline->op1.var);
48556 zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
48557
48558 if (IS_CV == IS_VAR) {
48559 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
48560 }
48561 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48562 }
48563
ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48564 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48565 {
48566 USE_OPLINE
48567 zval *container;
48568
48569 SAVE_OPLINE();
48570 container = EX_VAR(opline->op1.var);
48571 zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
48572
48573 if (IS_CV == IS_VAR) {
48574 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
48575 }
48576 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48577 }
48578
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48579 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48580 {
48581 #if 0
48582 USE_OPLINE
48583 #endif
48584
48585 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
48586 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
48587 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
48588 }
48589 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
48590 } else {
48591 if (IS_UNUSED == IS_UNUSED) {
48592 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
48593 }
48594 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
48595 }
48596 }
48597
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48598 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48599 {
48600 USE_OPLINE
48601 zval *object_ptr, *orig_object_ptr;
48602 zval *value;
48603 zval *variable_ptr;
48604 zval *dim;
48605 zend_refcounted *garbage = NULL;
48606
48607 SAVE_OPLINE();
48608 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48609
48610 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48611 try_assign_dim_array:
48612 SEPARATE_ARRAY(object_ptr);
48613 if (IS_UNUSED == IS_UNUSED) {
48614 value = RT_CONSTANT((opline+1), (opline+1)->op1);
48615 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48616 HashTable *ht = Z_ARRVAL_P(object_ptr);
48617 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48618 GC_ADDREF(ht);
48619 }
48620 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48621 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48622 zend_array_destroy(ht);
48623 goto assign_dim_error;
48624 }
48625 }
48626 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
48627 ZVAL_DEREF(value);
48628 }
48629 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48630 if (UNEXPECTED(value == NULL)) {
48631 zend_cannot_add_element();
48632 goto assign_dim_error;
48633 } else if (IS_CONST == IS_CV) {
48634 if (Z_REFCOUNTED_P(value)) {
48635 Z_ADDREF_P(value);
48636 }
48637 } else if (IS_CONST == IS_VAR) {
48638 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48639 if (Z_ISREF_P(free_op_data)) {
48640 if (Z_REFCOUNTED_P(value)) {
48641 Z_ADDREF_P(value);
48642 }
48643 zval_ptr_dtor_nogc(free_op_data);
48644 }
48645 } else if (IS_CONST == IS_CONST) {
48646 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48647 Z_ADDREF_P(value);
48648 }
48649 }
48650 } else {
48651 dim = NULL;
48652 if (IS_UNUSED == IS_CONST) {
48653 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48654 } else {
48655 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48656 }
48657 if (UNEXPECTED(variable_ptr == NULL)) {
48658 goto assign_dim_error;
48659 }
48660 value = RT_CONSTANT((opline+1), (opline+1)->op1);
48661 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
48662 }
48663 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48664 ZVAL_COPY(EX_VAR(opline->result.var), value);
48665 }
48666 if (garbage) {
48667 GC_DTOR_NO_REF(garbage);
48668 }
48669 } else {
48670 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48671 object_ptr = Z_REFVAL_P(object_ptr);
48672 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48673 goto try_assign_dim_array;
48674 }
48675 }
48676 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48677 zend_object *obj = Z_OBJ_P(object_ptr);
48678
48679 GC_ADDREF(obj);
48680 dim = NULL;
48681 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48682 dim = ZVAL_UNDEFINED_OP2();
48683 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48684 dim++;
48685 }
48686
48687 value = RT_CONSTANT((opline+1), (opline+1)->op1);
48688 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48689 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48690 } else if (IS_CONST & (IS_CV|IS_VAR)) {
48691 ZVAL_DEREF(value);
48692 }
48693
48694 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48695
48696 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48697 zend_objects_store_del(obj);
48698 }
48699 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48700 if (IS_UNUSED == IS_UNUSED) {
48701 zend_use_new_element_for_string();
48702
48703 UNDEF_RESULT();
48704 } else {
48705 dim = NULL;
48706 value = RT_CONSTANT((opline+1), (opline+1)->op1);
48707 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48708
48709 }
48710 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48711 if (Z_ISREF_P(orig_object_ptr)
48712 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48713 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48714 dim = NULL;
48715
48716 UNDEF_RESULT();
48717 } else {
48718 HashTable *ht = zend_new_array(8);
48719 uint8_t old_type = Z_TYPE_P(object_ptr);
48720
48721 ZVAL_ARR(object_ptr, ht);
48722 if (UNEXPECTED(old_type == IS_FALSE)) {
48723 GC_ADDREF(ht);
48724 zend_false_to_array_deprecated();
48725 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48726 zend_array_destroy(ht);
48727 goto assign_dim_error;
48728 }
48729 }
48730 goto try_assign_dim_array;
48731 }
48732 } else {
48733 zend_use_scalar_as_array();
48734 dim = NULL;
48735 assign_dim_error:
48736
48737 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48738 ZVAL_NULL(EX_VAR(opline->result.var));
48739 }
48740 }
48741 }
48742 if (IS_UNUSED != IS_UNUSED) {
48743
48744 }
48745
48746 /* assign_dim has two opcodes! */
48747 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48748 }
48749
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48750 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48751 {
48752 USE_OPLINE
48753 zval *object_ptr, *orig_object_ptr;
48754 zval *value;
48755 zval *variable_ptr;
48756 zval *dim;
48757 zend_refcounted *garbage = NULL;
48758
48759 SAVE_OPLINE();
48760 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48761
48762 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48763 try_assign_dim_array:
48764 SEPARATE_ARRAY(object_ptr);
48765 if (IS_UNUSED == IS_UNUSED) {
48766 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48767 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48768 HashTable *ht = Z_ARRVAL_P(object_ptr);
48769 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48770 GC_ADDREF(ht);
48771 }
48772 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48773 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48774 zend_array_destroy(ht);
48775 goto assign_dim_error;
48776 }
48777 }
48778 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
48779 ZVAL_DEREF(value);
48780 }
48781 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48782 if (UNEXPECTED(value == NULL)) {
48783 zend_cannot_add_element();
48784 goto assign_dim_error;
48785 } else if (IS_TMP_VAR == IS_CV) {
48786 if (Z_REFCOUNTED_P(value)) {
48787 Z_ADDREF_P(value);
48788 }
48789 } else if (IS_TMP_VAR == IS_VAR) {
48790 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48791 if (Z_ISREF_P(free_op_data)) {
48792 if (Z_REFCOUNTED_P(value)) {
48793 Z_ADDREF_P(value);
48794 }
48795 zval_ptr_dtor_nogc(free_op_data);
48796 }
48797 } else if (IS_TMP_VAR == IS_CONST) {
48798 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48799 Z_ADDREF_P(value);
48800 }
48801 }
48802 } else {
48803 dim = NULL;
48804 if (IS_UNUSED == IS_CONST) {
48805 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48806 } else {
48807 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48808 }
48809 if (UNEXPECTED(variable_ptr == NULL)) {
48810 goto assign_dim_error;
48811 }
48812 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48813 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
48814 }
48815 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48816 ZVAL_COPY(EX_VAR(opline->result.var), value);
48817 }
48818 if (garbage) {
48819 GC_DTOR_NO_REF(garbage);
48820 }
48821 } else {
48822 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48823 object_ptr = Z_REFVAL_P(object_ptr);
48824 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48825 goto try_assign_dim_array;
48826 }
48827 }
48828 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48829 zend_object *obj = Z_OBJ_P(object_ptr);
48830
48831 GC_ADDREF(obj);
48832 dim = NULL;
48833 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48834 dim = ZVAL_UNDEFINED_OP2();
48835 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48836 dim++;
48837 }
48838
48839 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48840 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48841 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48842 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
48843 ZVAL_DEREF(value);
48844 }
48845
48846 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48847
48848 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48849 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48850 zend_objects_store_del(obj);
48851 }
48852 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48853 if (IS_UNUSED == IS_UNUSED) {
48854 zend_use_new_element_for_string();
48855 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48856 UNDEF_RESULT();
48857 } else {
48858 dim = NULL;
48859 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48860 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48861 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48862 }
48863 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48864 if (Z_ISREF_P(orig_object_ptr)
48865 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48866 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48867 dim = NULL;
48868 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48869 UNDEF_RESULT();
48870 } else {
48871 HashTable *ht = zend_new_array(8);
48872 uint8_t old_type = Z_TYPE_P(object_ptr);
48873
48874 ZVAL_ARR(object_ptr, ht);
48875 if (UNEXPECTED(old_type == IS_FALSE)) {
48876 GC_ADDREF(ht);
48877 zend_false_to_array_deprecated();
48878 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48879 zend_array_destroy(ht);
48880 goto assign_dim_error;
48881 }
48882 }
48883 goto try_assign_dim_array;
48884 }
48885 } else {
48886 zend_use_scalar_as_array();
48887 dim = NULL;
48888 assign_dim_error:
48889 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48890 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48891 ZVAL_NULL(EX_VAR(opline->result.var));
48892 }
48893 }
48894 }
48895 if (IS_UNUSED != IS_UNUSED) {
48896
48897 }
48898
48899 /* assign_dim has two opcodes! */
48900 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48901 }
48902
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48903 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48904 {
48905 USE_OPLINE
48906 zval *object_ptr, *orig_object_ptr;
48907 zval *value;
48908 zval *variable_ptr;
48909 zval *dim;
48910 zend_refcounted *garbage = NULL;
48911
48912 SAVE_OPLINE();
48913 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48914
48915 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48916 try_assign_dim_array:
48917 SEPARATE_ARRAY(object_ptr);
48918 if (IS_UNUSED == IS_UNUSED) {
48919 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48920 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48921 HashTable *ht = Z_ARRVAL_P(object_ptr);
48922 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48923 GC_ADDREF(ht);
48924 }
48925 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48926 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48927 zend_array_destroy(ht);
48928 goto assign_dim_error;
48929 }
48930 }
48931 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
48932 ZVAL_DEREF(value);
48933 }
48934 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48935 if (UNEXPECTED(value == NULL)) {
48936 zend_cannot_add_element();
48937 goto assign_dim_error;
48938 } else if (IS_VAR == IS_CV) {
48939 if (Z_REFCOUNTED_P(value)) {
48940 Z_ADDREF_P(value);
48941 }
48942 } else if (IS_VAR == IS_VAR) {
48943 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48944 if (Z_ISREF_P(free_op_data)) {
48945 if (Z_REFCOUNTED_P(value)) {
48946 Z_ADDREF_P(value);
48947 }
48948 zval_ptr_dtor_nogc(free_op_data);
48949 }
48950 } else if (IS_VAR == IS_CONST) {
48951 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48952 Z_ADDREF_P(value);
48953 }
48954 }
48955 } else {
48956 dim = NULL;
48957 if (IS_UNUSED == IS_CONST) {
48958 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48959 } else {
48960 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48961 }
48962 if (UNEXPECTED(variable_ptr == NULL)) {
48963 goto assign_dim_error;
48964 }
48965 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48966 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
48967 }
48968 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48969 ZVAL_COPY(EX_VAR(opline->result.var), value);
48970 }
48971 if (garbage) {
48972 GC_DTOR_NO_REF(garbage);
48973 }
48974 } else {
48975 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48976 object_ptr = Z_REFVAL_P(object_ptr);
48977 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48978 goto try_assign_dim_array;
48979 }
48980 }
48981 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48982 zend_object *obj = Z_OBJ_P(object_ptr);
48983
48984 GC_ADDREF(obj);
48985 dim = NULL;
48986 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48987 dim = ZVAL_UNDEFINED_OP2();
48988 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48989 dim++;
48990 }
48991
48992 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48993 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48994 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48995 } else if (IS_VAR & (IS_CV|IS_VAR)) {
48996 ZVAL_DEREF(value);
48997 }
48998
48999 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
49000
49001 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
49002 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
49003 zend_objects_store_del(obj);
49004 }
49005 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
49006 if (IS_UNUSED == IS_UNUSED) {
49007 zend_use_new_element_for_string();
49008 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
49009 UNDEF_RESULT();
49010 } else {
49011 dim = NULL;
49012 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
49013 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
49014 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
49015 }
49016 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
49017 if (Z_ISREF_P(orig_object_ptr)
49018 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
49019 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
49020 dim = NULL;
49021 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
49022 UNDEF_RESULT();
49023 } else {
49024 HashTable *ht = zend_new_array(8);
49025 uint8_t old_type = Z_TYPE_P(object_ptr);
49026
49027 ZVAL_ARR(object_ptr, ht);
49028 if (UNEXPECTED(old_type == IS_FALSE)) {
49029 GC_ADDREF(ht);
49030 zend_false_to_array_deprecated();
49031 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
49032 zend_array_destroy(ht);
49033 goto assign_dim_error;
49034 }
49035 }
49036 goto try_assign_dim_array;
49037 }
49038 } else {
49039 zend_use_scalar_as_array();
49040 dim = NULL;
49041 assign_dim_error:
49042 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
49043 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49044 ZVAL_NULL(EX_VAR(opline->result.var));
49045 }
49046 }
49047 }
49048 if (IS_UNUSED != IS_UNUSED) {
49049
49050 }
49051
49052 /* assign_dim has two opcodes! */
49053 ZEND_VM_NEXT_OPCODE_EX(1, 2);
49054 }
49055
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49056 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49057 {
49058 USE_OPLINE
49059 zval *object_ptr, *orig_object_ptr;
49060 zval *value;
49061 zval *variable_ptr;
49062 zval *dim;
49063 zend_refcounted *garbage = NULL;
49064
49065 SAVE_OPLINE();
49066 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
49067
49068 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
49069 try_assign_dim_array:
49070 SEPARATE_ARRAY(object_ptr);
49071 if (IS_UNUSED == IS_UNUSED) {
49072 value = EX_VAR((opline+1)->op1.var);
49073 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
49074 HashTable *ht = Z_ARRVAL_P(object_ptr);
49075 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
49076 GC_ADDREF(ht);
49077 }
49078 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
49079 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
49080 zend_array_destroy(ht);
49081 goto assign_dim_error;
49082 }
49083 }
49084 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
49085 ZVAL_DEREF(value);
49086 }
49087 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
49088 if (UNEXPECTED(value == NULL)) {
49089 zend_cannot_add_element();
49090 goto assign_dim_error;
49091 } else if (IS_CV == IS_CV) {
49092 if (Z_REFCOUNTED_P(value)) {
49093 Z_ADDREF_P(value);
49094 }
49095 } else if (IS_CV == IS_VAR) {
49096 zval *free_op_data = EX_VAR((opline+1)->op1.var);
49097 if (Z_ISREF_P(free_op_data)) {
49098 if (Z_REFCOUNTED_P(value)) {
49099 Z_ADDREF_P(value);
49100 }
49101 zval_ptr_dtor_nogc(free_op_data);
49102 }
49103 } else if (IS_CV == IS_CONST) {
49104 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
49105 Z_ADDREF_P(value);
49106 }
49107 }
49108 } else {
49109 dim = NULL;
49110 if (IS_UNUSED == IS_CONST) {
49111 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
49112 } else {
49113 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
49114 }
49115 if (UNEXPECTED(variable_ptr == NULL)) {
49116 goto assign_dim_error;
49117 }
49118 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
49119 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
49120 }
49121 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49122 ZVAL_COPY(EX_VAR(opline->result.var), value);
49123 }
49124 if (garbage) {
49125 GC_DTOR_NO_REF(garbage);
49126 }
49127 } else {
49128 if (EXPECTED(Z_ISREF_P(object_ptr))) {
49129 object_ptr = Z_REFVAL_P(object_ptr);
49130 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
49131 goto try_assign_dim_array;
49132 }
49133 }
49134 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
49135 zend_object *obj = Z_OBJ_P(object_ptr);
49136
49137 GC_ADDREF(obj);
49138 dim = NULL;
49139 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
49140 dim = ZVAL_UNDEFINED_OP2();
49141 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
49142 dim++;
49143 }
49144
49145 value = EX_VAR((opline+1)->op1.var);
49146 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
49147 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
49148 } else if (IS_CV & (IS_CV|IS_VAR)) {
49149 ZVAL_DEREF(value);
49150 }
49151
49152 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
49153
49154 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
49155 zend_objects_store_del(obj);
49156 }
49157 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
49158 if (IS_UNUSED == IS_UNUSED) {
49159 zend_use_new_element_for_string();
49160
49161 UNDEF_RESULT();
49162 } else {
49163 dim = NULL;
49164 value = EX_VAR((opline+1)->op1.var);
49165 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
49166
49167 }
49168 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
49169 if (Z_ISREF_P(orig_object_ptr)
49170 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
49171 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
49172 dim = NULL;
49173
49174 UNDEF_RESULT();
49175 } else {
49176 HashTable *ht = zend_new_array(8);
49177 uint8_t old_type = Z_TYPE_P(object_ptr);
49178
49179 ZVAL_ARR(object_ptr, ht);
49180 if (UNEXPECTED(old_type == IS_FALSE)) {
49181 GC_ADDREF(ht);
49182 zend_false_to_array_deprecated();
49183 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
49184 zend_array_destroy(ht);
49185 goto assign_dim_error;
49186 }
49187 }
49188 goto try_assign_dim_array;
49189 }
49190 } else {
49191 zend_use_scalar_as_array();
49192 dim = NULL;
49193 assign_dim_error:
49194
49195 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49196 ZVAL_NULL(EX_VAR(opline->result.var));
49197 }
49198 }
49199 }
49200 if (IS_UNUSED != IS_UNUSED) {
49201
49202 }
49203
49204 /* assign_dim has two opcodes! */
49205 ZEND_VM_NEXT_OPCODE_EX(1, 2);
49206 }
49207
ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49208 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49209 {
49210 if (IS_CV == IS_UNUSED) {
49211 SAVE_OPLINE();
49212 zend_verify_missing_return_type(EX(func));
49213 HANDLE_EXCEPTION();
49214 } else {
49215 /* prevents "undefined variable opline" errors */
49216 #if 0 || (IS_CV != IS_UNUSED)
49217 USE_OPLINE
49218 zval *retval_ref, *retval_ptr;
49219 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
49220 retval_ref = retval_ptr = EX_VAR(opline->op1.var);
49221
49222 if (IS_CV == IS_CONST) {
49223 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
49224 retval_ref = retval_ptr = EX_VAR(opline->result.var);
49225 } else if (IS_CV == IS_VAR) {
49226 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
49227 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
49228 }
49229 ZVAL_DEREF(retval_ptr);
49230 } else if (IS_CV == IS_CV) {
49231 ZVAL_DEREF(retval_ptr);
49232 }
49233
49234 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
49235 ZEND_VM_NEXT_OPCODE();
49236 }
49237
49238 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
49239 SAVE_OPLINE();
49240 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
49241 if (UNEXPECTED(EG(exception))) {
49242 HANDLE_EXCEPTION();
49243 }
49244 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
49245 ZEND_VM_NEXT_OPCODE();
49246 }
49247 }
49248
49249 zend_reference *ref = NULL;
49250 void *cache_slot = CACHE_ADDR(opline->op2.num);
49251 if (UNEXPECTED(retval_ref != retval_ptr)) {
49252 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
49253 ref = Z_REF_P(retval_ref);
49254 } else {
49255 /* A cast might happen - unwrap the reference if this is a by-value return */
49256 if (Z_REFCOUNT_P(retval_ref) == 1) {
49257 ZVAL_UNREF(retval_ref);
49258 } else {
49259 Z_DELREF_P(retval_ref);
49260 ZVAL_COPY(retval_ref, retval_ptr);
49261 }
49262 retval_ptr = retval_ref;
49263 }
49264 }
49265
49266 SAVE_OPLINE();
49267 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
49268 zend_verify_return_error(EX(func), retval_ptr);
49269 HANDLE_EXCEPTION();
49270 }
49271 ZEND_VM_NEXT_OPCODE();
49272 #endif
49273 }
49274 }
49275
ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49276 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49277 {
49278 USE_OPLINE
49279 zval *varptr, *arg;
49280
49281 if (IS_UNUSED == IS_CONST) {
49282 SAVE_OPLINE();
49283 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
49284 uint32_t arg_num;
49285 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
49286 if (UNEXPECTED(!arg)) {
49287
49288 HANDLE_EXCEPTION();
49289 }
49290 } else {
49291 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
49292 }
49293
49294 varptr = EX_VAR(opline->op1.var);
49295 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
49296 SAVE_OPLINE();
49297 ZVAL_UNDEFINED_OP1();
49298 ZVAL_NULL(arg);
49299 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49300 }
49301
49302 if (IS_CV == IS_CV) {
49303 ZVAL_COPY_DEREF(arg, varptr);
49304 } else /* if (IS_CV == IS_VAR) */ {
49305 if (UNEXPECTED(Z_ISREF_P(varptr))) {
49306 zend_refcounted *ref = Z_COUNTED_P(varptr);
49307
49308 varptr = Z_REFVAL_P(varptr);
49309 ZVAL_COPY_VALUE(arg, varptr);
49310 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
49311 efree_size(ref, sizeof(zend_reference));
49312 } else if (Z_OPT_REFCOUNTED_P(arg)) {
49313 Z_ADDREF_P(arg);
49314 }
49315 } else {
49316 ZVAL_COPY_VALUE(arg, varptr);
49317 }
49318 }
49319
49320 ZEND_VM_NEXT_OPCODE();
49321 }
49322
ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49323 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49324 {
49325 USE_OPLINE
49326 zval *varptr, *arg;
49327
49328 SAVE_OPLINE();
49329 if (IS_UNUSED == IS_CONST) {
49330 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
49331 uint32_t arg_num;
49332 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
49333 if (UNEXPECTED(!arg)) {
49334
49335 HANDLE_EXCEPTION();
49336 }
49337 } else {
49338 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
49339 }
49340
49341 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49342 if (Z_ISREF_P(varptr)) {
49343 Z_ADDREF_P(varptr);
49344 } else {
49345 ZVAL_MAKE_REF_EX(varptr, 2);
49346 }
49347 ZVAL_REF(arg, Z_REF_P(varptr));
49348
49349 ZEND_VM_NEXT_OPCODE();
49350 }
49351
ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49352 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49353 {
49354 USE_OPLINE
49355 zval *varptr, *arg;
49356 uint32_t arg_num;
49357
49358 if (IS_UNUSED == IS_CONST) {
49359 SAVE_OPLINE();
49360 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
49361 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
49362 if (UNEXPECTED(!arg)) {
49363
49364 HANDLE_EXCEPTION();
49365 }
49366 } else {
49367 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
49368 arg_num = opline->op2.num;
49369 }
49370
49371 if (EXPECTED(0)) {
49372 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
49373 goto send_var_by_ref;
49374 }
49375 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
49376 send_var_by_ref:
49377 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49378 if (Z_ISREF_P(varptr)) {
49379 Z_ADDREF_P(varptr);
49380 } else {
49381 ZVAL_MAKE_REF_EX(varptr, 2);
49382 }
49383 ZVAL_REF(arg, Z_REF_P(varptr));
49384
49385 ZEND_VM_NEXT_OPCODE();
49386 }
49387
49388 varptr = EX_VAR(opline->op1.var);
49389 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
49390 SAVE_OPLINE();
49391 ZVAL_UNDEFINED_OP1();
49392 ZVAL_NULL(arg);
49393 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49394 }
49395
49396 if (IS_CV == IS_CV) {
49397 ZVAL_COPY_DEREF(arg, varptr);
49398 } else /* if (IS_CV == IS_VAR) */ {
49399 if (UNEXPECTED(Z_ISREF_P(varptr))) {
49400 zend_refcounted *ref = Z_COUNTED_P(varptr);
49401
49402 varptr = Z_REFVAL_P(varptr);
49403 ZVAL_COPY_VALUE(arg, varptr);
49404 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
49405 efree_size(ref, sizeof(zend_reference));
49406 } else if (Z_OPT_REFCOUNTED_P(arg)) {
49407 Z_ADDREF_P(arg);
49408 }
49409 } else {
49410 ZVAL_COPY_VALUE(arg, varptr);
49411 }
49412 }
49413
49414 ZEND_VM_NEXT_OPCODE();
49415 }
49416
ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49417 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49418 {
49419 USE_OPLINE
49420 zval *varptr, *arg;
49421 uint32_t arg_num;
49422
49423 if (IS_UNUSED == IS_CONST) {
49424 SAVE_OPLINE();
49425 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
49426 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
49427 if (UNEXPECTED(!arg)) {
49428
49429 HANDLE_EXCEPTION();
49430 }
49431 } else {
49432 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
49433 arg_num = opline->op2.num;
49434 }
49435
49436 if (EXPECTED(1)) {
49437 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
49438 goto send_var_by_ref;
49439 }
49440 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
49441 send_var_by_ref:
49442 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49443 if (Z_ISREF_P(varptr)) {
49444 Z_ADDREF_P(varptr);
49445 } else {
49446 ZVAL_MAKE_REF_EX(varptr, 2);
49447 }
49448 ZVAL_REF(arg, Z_REF_P(varptr));
49449
49450 ZEND_VM_NEXT_OPCODE();
49451 }
49452
49453 varptr = EX_VAR(opline->op1.var);
49454 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
49455 SAVE_OPLINE();
49456 ZVAL_UNDEFINED_OP1();
49457 ZVAL_NULL(arg);
49458 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49459 }
49460
49461 if (IS_CV == IS_CV) {
49462 ZVAL_COPY_DEREF(arg, varptr);
49463 } else /* if (IS_CV == IS_VAR) */ {
49464 if (UNEXPECTED(Z_ISREF_P(varptr))) {
49465 zend_refcounted *ref = Z_COUNTED_P(varptr);
49466
49467 varptr = Z_REFVAL_P(varptr);
49468 ZVAL_COPY_VALUE(arg, varptr);
49469 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
49470 efree_size(ref, sizeof(zend_reference));
49471 } else if (Z_OPT_REFCOUNTED_P(arg)) {
49472 Z_ADDREF_P(arg);
49473 }
49474 } else {
49475 ZVAL_COPY_VALUE(arg, varptr);
49476 }
49477 }
49478
49479 ZEND_VM_NEXT_OPCODE();
49480 }
49481
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49482 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49483 {
49484 USE_OPLINE
49485 zval *expr_ptr, new_expr;
49486
49487 SAVE_OPLINE();
49488 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
49489 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
49490 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49491 if (Z_ISREF_P(expr_ptr)) {
49492 Z_ADDREF_P(expr_ptr);
49493 } else {
49494 ZVAL_MAKE_REF_EX(expr_ptr, 2);
49495 }
49496
49497 } else {
49498 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49499 if (IS_CV == IS_TMP_VAR) {
49500 /* pass */
49501 } else if (IS_CV == IS_CONST) {
49502 Z_TRY_ADDREF_P(expr_ptr);
49503 } else if (IS_CV == IS_CV) {
49504 ZVAL_DEREF(expr_ptr);
49505 Z_TRY_ADDREF_P(expr_ptr);
49506 } else /* if (IS_CV == IS_VAR) */ {
49507 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
49508 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
49509
49510 expr_ptr = Z_REFVAL_P(expr_ptr);
49511 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
49512 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
49513 expr_ptr = &new_expr;
49514 efree_size(ref, sizeof(zend_reference));
49515 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
49516 Z_ADDREF_P(expr_ptr);
49517 }
49518 }
49519 }
49520 }
49521
49522 if (IS_UNUSED != IS_UNUSED) {
49523 zval *offset = NULL;
49524 zend_string *str;
49525 zend_ulong hval;
49526
49527 add_again:
49528 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
49529 str = Z_STR_P(offset);
49530 if (IS_UNUSED != IS_CONST) {
49531 if (ZEND_HANDLE_NUMERIC(str, hval)) {
49532 goto num_index;
49533 }
49534 }
49535 str_index:
49536 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
49537 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
49538 hval = Z_LVAL_P(offset);
49539 num_index:
49540 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
49541 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
49542 offset = Z_REFVAL_P(offset);
49543 goto add_again;
49544 } else if (Z_TYPE_P(offset) == IS_NULL) {
49545 str = ZSTR_EMPTY_ALLOC();
49546 goto str_index;
49547 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
49548 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
49549 goto num_index;
49550 } else if (Z_TYPE_P(offset) == IS_FALSE) {
49551 hval = 0;
49552 goto num_index;
49553 } else if (Z_TYPE_P(offset) == IS_TRUE) {
49554 hval = 1;
49555 goto num_index;
49556 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
49557 zend_use_resource_as_offset(offset);
49558 hval = Z_RES_HANDLE_P(offset);
49559 goto num_index;
49560 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
49561 ZVAL_UNDEFINED_OP2();
49562 str = ZSTR_EMPTY_ALLOC();
49563 goto str_index;
49564 } else {
49565 zend_illegal_array_offset_access(offset);
49566 zval_ptr_dtor_nogc(expr_ptr);
49567 }
49568
49569 } else {
49570 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
49571 zend_cannot_add_element();
49572 zval_ptr_dtor_nogc(expr_ptr);
49573 }
49574 }
49575 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49576 }
49577
ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49578 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49579 {
49580 zval *array;
49581 uint32_t size;
49582 USE_OPLINE
49583
49584 array = EX_VAR(opline->result.var);
49585 if (IS_CV != IS_UNUSED) {
49586 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
49587 ZVAL_ARR(array, zend_new_array(size));
49588 /* Explicitly initialize array as not-packed if flag is set */
49589 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
49590 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
49591 }
49592 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49593 } else {
49594 ZVAL_ARR(array, zend_new_array(0));
49595 ZEND_VM_NEXT_OPCODE();
49596 }
49597 }
49598
ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49599 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49600 {
49601 USE_OPLINE
49602 zval *var = EX_VAR(opline->op1.var);
49603
49604 if (Z_REFCOUNTED_P(var)) {
49605 zend_refcounted *garbage = Z_COUNTED_P(var);
49606
49607 ZVAL_UNDEF(var);
49608 SAVE_OPLINE();
49609 GC_DTOR(garbage);
49610 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49611 } else {
49612 ZVAL_UNDEF(var);
49613 }
49614 ZEND_VM_NEXT_OPCODE();
49615 }
49616
ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49617 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49618 {
49619 USE_OPLINE
49620 zval *varname;
49621 zend_string *name, *tmp_name;
49622 HashTable *target_symbol_table;
49623
49624 SAVE_OPLINE();
49625
49626 varname = EX_VAR(opline->op1.var);
49627
49628 if (IS_CV == IS_CONST) {
49629 name = Z_STR_P(varname);
49630 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
49631 name = Z_STR_P(varname);
49632 tmp_name = NULL;
49633 } else {
49634 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
49635 varname = ZVAL_UNDEFINED_OP1();
49636 }
49637 name = zval_try_get_tmp_string(varname, &tmp_name);
49638 if (UNEXPECTED(!name)) {
49639
49640 HANDLE_EXCEPTION();
49641 }
49642 }
49643
49644 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
49645 zend_hash_del_ind(target_symbol_table, name);
49646
49647 if (IS_CV != IS_CONST) {
49648 zend_tmp_string_release(tmp_name);
49649 }
49650
49651 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49652 }
49653
49654 /* 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)49655 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49656 {
49657 USE_OPLINE
49658 zval *value;
49659
49660 value = EX_VAR(opline->op1.var);
49661 if (!(0)) {
49662 if (Z_TYPE_P(value) > IS_NULL &&
49663 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
49664 ZEND_VM_SMART_BRANCH_TRUE();
49665 } else {
49666 ZEND_VM_SMART_BRANCH_FALSE();
49667 }
49668 } else {
49669 bool result;
49670
49671 SAVE_OPLINE();
49672 result = !i_zend_is_true(value);
49673 ZEND_VM_SMART_BRANCH(result, 1);
49674 }
49675 }
49676
ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49677 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49678 {
49679 USE_OPLINE
49680 zval *value;
49681
49682 value = EX_VAR(opline->op1.var);
49683 if (!(1)) {
49684 if (Z_TYPE_P(value) > IS_NULL &&
49685 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
49686 ZEND_VM_SMART_BRANCH_TRUE();
49687 } else {
49688 ZEND_VM_SMART_BRANCH_FALSE();
49689 }
49690 } else {
49691 bool result;
49692
49693 SAVE_OPLINE();
49694 result = !i_zend_is_true(value);
49695 ZEND_VM_SMART_BRANCH(result, 1);
49696 }
49697 }
49698
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49699 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49700 {
49701 USE_OPLINE
49702 zval *value;
49703 /* Should be bool result? as below got: result = (opline->extended_value & ZEND_ISEMPTY) */
49704 int result;
49705 zval *varname;
49706 zend_string *name, *tmp_name;
49707 HashTable *target_symbol_table;
49708
49709 SAVE_OPLINE();
49710 varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
49711 if (IS_CV == IS_CONST) {
49712 name = Z_STR_P(varname);
49713 } else {
49714 name = zval_get_tmp_string(varname, &tmp_name);
49715 }
49716
49717 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
49718 value = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
49719
49720 if (IS_CV != IS_CONST) {
49721 zend_tmp_string_release(tmp_name);
49722 }
49723
49724 if (!value) {
49725 result = (opline->extended_value & ZEND_ISEMPTY);
49726 } else {
49727 if (Z_TYPE_P(value) == IS_INDIRECT) {
49728 value = Z_INDIRECT_P(value);
49729 }
49730 if (!(opline->extended_value & ZEND_ISEMPTY)) {
49731 if (Z_ISREF_P(value)) {
49732 value = Z_REFVAL_P(value);
49733 }
49734 result = Z_TYPE_P(value) > IS_NULL;
49735 } else {
49736 result = !i_zend_is_true(value);
49737 }
49738 }
49739
49740 ZEND_VM_SMART_BRANCH(result, 1);
49741 }
49742
49743 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49744 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49745 {
49746 USE_OPLINE
49747 zval *expr;
49748 bool result;
49749
49750 SAVE_OPLINE();
49751 expr = EX_VAR(opline->op1.var);
49752
49753 try_instanceof:
49754 if (Z_TYPE_P(expr) == IS_OBJECT) {
49755 zend_class_entry *ce;
49756
49757 if (IS_UNUSED == IS_CONST) {
49758 ce = CACHED_PTR(opline->extended_value);
49759 if (UNEXPECTED(ce == NULL)) {
49760 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);
49761 if (EXPECTED(ce)) {
49762 CACHE_PTR(opline->extended_value, ce);
49763 }
49764 }
49765 } else if (IS_UNUSED == IS_UNUSED) {
49766 ce = zend_fetch_class(NULL, opline->op2.num);
49767 if (UNEXPECTED(ce == NULL)) {
49768
49769 ZVAL_UNDEF(EX_VAR(opline->result.var));
49770 HANDLE_EXCEPTION();
49771 }
49772 } else {
49773 ce = Z_CE_P(EX_VAR(opline->op2.var));
49774 }
49775 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
49776 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
49777 expr = Z_REFVAL_P(expr);
49778 goto try_instanceof;
49779 } else {
49780 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
49781 ZVAL_UNDEFINED_OP1();
49782 }
49783 result = 0;
49784 }
49785
49786 ZEND_VM_SMART_BRANCH(result, 1);
49787 }
49788
ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49789 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49790 {
49791 USE_OPLINE
49792
49793 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
49794
49795 SAVE_OPLINE();
49796 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
49797 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49798 }
49799
49800 /* Destroy the previously yielded value */
49801 zval_ptr_dtor(&generator->value);
49802
49803 /* Destroy the previously yielded key */
49804 zval_ptr_dtor(&generator->key);
49805
49806 /* Set the new yielded value */
49807 if (IS_CV != IS_UNUSED) {
49808 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
49809 /* Constants and temporary variables aren't yieldable by reference,
49810 * but we still allow them with a notice. */
49811 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
49812 zval *value;
49813
49814 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49815
49816 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49817 ZVAL_COPY_VALUE(&generator->value, value);
49818 if (IS_CV == IS_CONST) {
49819 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49820 Z_ADDREF(generator->value);
49821 }
49822 }
49823 } else {
49824 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49825
49826 /* If a function call result is yielded and the function did
49827 * not return by reference we throw a notice. */
49828 do {
49829 if (IS_CV == IS_VAR) {
49830 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
49831 if (opline->extended_value == ZEND_RETURNS_FUNCTION
49832 && !Z_ISREF_P(value_ptr)) {
49833 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49834 ZVAL_COPY(&generator->value, value_ptr);
49835 break;
49836 }
49837 }
49838 if (Z_ISREF_P(value_ptr)) {
49839 Z_ADDREF_P(value_ptr);
49840 } else {
49841 ZVAL_MAKE_REF_EX(value_ptr, 2);
49842 }
49843 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
49844 } while (0);
49845
49846 }
49847 } else {
49848 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49849
49850 /* Consts, temporary variables and references need copying */
49851 if (IS_CV == IS_CONST) {
49852 ZVAL_COPY_VALUE(&generator->value, value);
49853 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49854 Z_ADDREF(generator->value);
49855 }
49856 } else if (IS_CV == IS_TMP_VAR) {
49857 ZVAL_COPY_VALUE(&generator->value, value);
49858 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
49859 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
49860
49861 } else {
49862 ZVAL_COPY_VALUE(&generator->value, value);
49863 if (IS_CV == IS_CV) {
49864 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
49865 }
49866 }
49867 }
49868 } else {
49869 /* If no value was specified yield null */
49870 ZVAL_NULL(&generator->value);
49871 }
49872
49873 /* Set the new yielded key */
49874 if (IS_UNUSED != IS_UNUSED) {
49875 zval *key = NULL;
49876 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
49877 key = Z_REFVAL_P(key);
49878 }
49879 ZVAL_COPY(&generator->key, key);
49880
49881 if (Z_TYPE(generator->key) == IS_LONG
49882 && Z_LVAL(generator->key) > generator->largest_used_integer_key
49883 ) {
49884 generator->largest_used_integer_key = Z_LVAL(generator->key);
49885 }
49886 } else {
49887 /* If no key was specified we use auto-increment keys */
49888 generator->largest_used_integer_key++;
49889 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
49890 }
49891
49892 if (RETURN_VALUE_USED(opline)) {
49893 /* If the return value of yield is used set the send
49894 * target and initialize it to NULL */
49895 generator->send_target = EX_VAR(opline->result.var);
49896 ZVAL_NULL(generator->send_target);
49897 } else {
49898 generator->send_target = NULL;
49899 }
49900
49901 /* We increment to the next op, so we are at the correct position when the
49902 * generator is resumed. */
49903 ZEND_VM_INC_OPCODE();
49904
49905 /* The GOTO VM uses a local opline variable. We need to set the opline
49906 * variable in execute_data so we don't resume at an old position. */
49907 SAVE_OPLINE();
49908
49909 ZEND_VM_RETURN();
49910 }
49911
ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49912 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49913 {
49914 USE_OPLINE
49915 zval *op1 = EX_VAR(opline->op1.var);
49916
49917 if (UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
49918 SAVE_OPLINE();
49919 ZVAL_UNDEFINED_OP1();
49920 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49921 }
49922 ZEND_VM_NEXT_OPCODE();
49923 }
49924
ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49925 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49926 {
49927 USE_OPLINE
49928 zval *op1 = EX_VAR(opline->op1.var);
49929
49930 if (IS_CV == IS_CV) {
49931 if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
49932 ZVAL_NEW_EMPTY_REF(op1);
49933 Z_SET_REFCOUNT_P(op1, 2);
49934 ZVAL_NULL(Z_REFVAL_P(op1));
49935 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
49936 } else {
49937 if (Z_ISREF_P(op1)) {
49938 Z_ADDREF_P(op1);
49939 } else {
49940 ZVAL_MAKE_REF_EX(op1, 2);
49941 }
49942 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
49943 }
49944 } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
49945 op1 = Z_INDIRECT_P(op1);
49946 if (EXPECTED(!Z_ISREF_P(op1))) {
49947 ZVAL_MAKE_REF_EX(op1, 2);
49948 } else {
49949 GC_ADDREF(Z_REF_P(op1));
49950 }
49951 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
49952 } else {
49953 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
49954 }
49955 ZEND_VM_NEXT_OPCODE();
49956 }
49957
ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49958 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49959 {
49960 USE_OPLINE
49961 zval *op1;
49962 zend_long count;
49963
49964 SAVE_OPLINE();
49965 op1 = EX_VAR(opline->op1.var);
49966
49967 while (1) {
49968 if (Z_TYPE_P(op1) == IS_ARRAY) {
49969 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
49970 break;
49971 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
49972 zend_object *zobj = Z_OBJ_P(op1);
49973
49974 /* first, we check if the handler is defined */
49975 if (zobj->handlers->count_elements) {
49976 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
49977 break;
49978 }
49979 if (UNEXPECTED(EG(exception))) {
49980 count = 0;
49981 break;
49982 }
49983 }
49984
49985 /* if not and the object implements Countable we call its count() method */
49986 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
49987 zval retval;
49988
49989 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
49990 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
49991 count = zval_get_long(&retval);
49992 zval_ptr_dtor(&retval);
49993 break;
49994 }
49995
49996 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
49997 } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
49998 op1 = Z_REFVAL_P(op1);
49999 continue;
50000 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
50001 ZVAL_UNDEFINED_OP1();
50002 }
50003 count = 0;
50004 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));
50005 break;
50006 }
50007
50008 ZVAL_LONG(EX_VAR(opline->result.var), count);
50009
50010 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50011 }
50012
ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50013 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50014 {
50015 USE_OPLINE
50016 zend_array *ht = Z_ARRVAL_P(EX_VAR(opline->op1.var));
50017 ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
50018 if (IS_CV & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50019 SAVE_OPLINE();
50020 zend_array_destroy(ht);
50021 if (EG(exception)) {
50022 HANDLE_EXCEPTION();
50023 }
50024 }
50025 ZEND_VM_NEXT_OPCODE();
50026 }
50027
ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50028 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50029 {
50030 USE_OPLINE
50031
50032 if (IS_CV == IS_UNUSED) {
50033 SAVE_OPLINE();
50034 if (UNEXPECTED(!EX(func)->common.scope)) {
50035 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
50036 ZVAL_UNDEF(EX_VAR(opline->result.var));
50037 HANDLE_EXCEPTION();
50038 } else {
50039 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
50040 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
50041 if (UNEXPECTED(EG(exception))) {
50042 HANDLE_EXCEPTION();
50043 }
50044 ZEND_VM_NEXT_OPCODE();
50045 }
50046 } else {
50047 zval *op1;
50048
50049 SAVE_OPLINE();
50050 op1 = EX_VAR(opline->op1.var);
50051 while (1) {
50052 if (Z_TYPE_P(op1) == IS_OBJECT) {
50053 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
50054 } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
50055 op1 = Z_REFVAL_P(op1);
50056 continue;
50057 } else {
50058 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
50059 ZVAL_UNDEFINED_OP1();
50060 }
50061 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
50062 ZVAL_UNDEF(EX_VAR(opline->result.var));
50063 }
50064 break;
50065 }
50066
50067 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50068 }
50069 }
50070
ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50071 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50072 {
50073 USE_OPLINE
50074 zval *op1;
50075 zend_string *type;
50076
50077 SAVE_OPLINE();
50078 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50079 type = zend_zval_get_legacy_type(op1);
50080 if (EXPECTED(type)) {
50081 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
50082 } else {
50083 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
50084 }
50085
50086 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50087 }
50088
ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50089 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50090 {
50091 USE_OPLINE
50092 zval *varptr, *arg;
50093 uint32_t arg_num = opline->op2.num;
50094
50095 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50096 ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50097 }
50098
50099 varptr = EX_VAR(opline->op1.var);
50100 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50101
50102 if (IS_CV == IS_CV) {
50103 ZVAL_COPY(arg, varptr);
50104 } else /* if (IS_CV == IS_VAR) */ {
50105 ZVAL_COPY_VALUE(arg, varptr);
50106 }
50107
50108 ZEND_VM_NEXT_OPCODE();
50109 }
50110
ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50111 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50112 {
50113 USE_OPLINE
50114 zval *op1, *op2;
50115
50116 SAVE_OPLINE();
50117 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50118 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50119 div_function(EX_VAR(opline->result.var), op1, op2);
50120
50121
50122 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50123 }
50124
ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50125 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50126 {
50127 USE_OPLINE
50128 zval *op1, *op2;
50129
50130 SAVE_OPLINE();
50131 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50132 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50133 pow_function(EX_VAR(opline->result.var), op1, op2);
50134
50135
50136 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50137 }
50138
ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50139 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50140 {
50141 USE_OPLINE
50142 zval *op1, *op2;
50143
50144 op1 = EX_VAR(opline->op1.var);
50145 op2 = EX_VAR(opline->op2.var);
50146
50147 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
50148 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
50149 zend_string *op1_str = Z_STR_P(op1);
50150 zend_string *op2_str = Z_STR_P(op2);
50151 zend_string *str;
50152 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
50153
50154 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
50155 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
50156 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
50157 } else {
50158 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
50159 }
50160 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50161 zend_string_release_ex(op1_str, 0);
50162 }
50163 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
50164 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
50165 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
50166 } else {
50167 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
50168 }
50169 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50170 zend_string_release_ex(op2_str, 0);
50171 }
50172 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
50173 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
50174 size_t len = ZSTR_LEN(op1_str);
50175
50176 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
50177 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
50178 }
50179 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
50180 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
50181 GC_ADD_FLAGS(str, flags);
50182 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
50183 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50184 zend_string_release_ex(op2_str, 0);
50185 }
50186 } else {
50187 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
50188 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
50189 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
50190 GC_ADD_FLAGS(str, flags);
50191 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
50192 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50193 zend_string_release_ex(op1_str, 0);
50194 }
50195 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50196 zend_string_release_ex(op2_str, 0);
50197 }
50198 }
50199 ZEND_VM_NEXT_OPCODE();
50200 } else {
50201 SAVE_OPLINE();
50202
50203 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
50204 op1 = ZVAL_UNDEFINED_OP1();
50205 }
50206 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
50207 op2 = ZVAL_UNDEFINED_OP2();
50208 }
50209 concat_function(EX_VAR(opline->result.var), op1, op2);
50210
50211
50212 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50213 }
50214 }
50215
ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50216 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50217 {
50218 USE_OPLINE
50219 zval *op1, *op2;
50220 bool result;
50221
50222 SAVE_OPLINE();
50223 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50224 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50225 result = fast_is_identical_function(op1, op2);
50226
50227
50228 ZEND_VM_SMART_BRANCH(result, 1);
50229 }
50230
ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50231 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50232 {
50233 USE_OPLINE
50234 zval *op1, *op2;
50235 bool result;
50236
50237 SAVE_OPLINE();
50238 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50239 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50240 result = fast_is_not_identical_function(op1, op2);
50241
50242
50243 ZEND_VM_SMART_BRANCH(result, 1);
50244 }
50245
ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50246 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50247 {
50248 USE_OPLINE
50249 zval *op1, *op2;
50250 double d1, d2;
50251
50252 op1 = EX_VAR(opline->op1.var);
50253 op2 = EX_VAR(opline->op2.var);
50254 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50255 /* pass */
50256 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50257 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50258 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
50259 is_equal_true:
50260 ZEND_VM_SMART_BRANCH_TRUE_NONE();
50261 } else {
50262 is_equal_false:
50263 ZEND_VM_SMART_BRANCH_FALSE_NONE();
50264 }
50265 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50266 d1 = (double)Z_LVAL_P(op1);
50267 d2 = Z_DVAL_P(op2);
50268 goto is_equal_double;
50269 }
50270 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50271 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50272 d1 = Z_DVAL_P(op1);
50273 d2 = Z_DVAL_P(op2);
50274 is_equal_double:
50275 if (d1 == d2) {
50276 goto is_equal_true;
50277 } else {
50278 goto is_equal_false;
50279 }
50280 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50281 d1 = Z_DVAL_P(op1);
50282 d2 = (double)Z_LVAL_P(op2);
50283 goto is_equal_double;
50284 }
50285 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50286 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50287 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50288 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50289 zval_ptr_dtor_str(op1);
50290 }
50291 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50292 zval_ptr_dtor_str(op2);
50293 }
50294 if (result) {
50295 goto is_equal_true;
50296 } else {
50297 goto is_equal_false;
50298 }
50299 }
50300 }
50301 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50302 }
50303
ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50304 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50305 {
50306 USE_OPLINE
50307 zval *op1, *op2;
50308 double d1, d2;
50309
50310 op1 = EX_VAR(opline->op1.var);
50311 op2 = EX_VAR(opline->op2.var);
50312 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50313 /* pass */
50314 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50315 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50316 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
50317 is_equal_true:
50318 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
50319 } else {
50320 is_equal_false:
50321 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
50322 }
50323 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50324 d1 = (double)Z_LVAL_P(op1);
50325 d2 = Z_DVAL_P(op2);
50326 goto is_equal_double;
50327 }
50328 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50329 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50330 d1 = Z_DVAL_P(op1);
50331 d2 = Z_DVAL_P(op2);
50332 is_equal_double:
50333 if (d1 == d2) {
50334 goto is_equal_true;
50335 } else {
50336 goto is_equal_false;
50337 }
50338 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50339 d1 = Z_DVAL_P(op1);
50340 d2 = (double)Z_LVAL_P(op2);
50341 goto is_equal_double;
50342 }
50343 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50344 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50345 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50346 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50347 zval_ptr_dtor_str(op1);
50348 }
50349 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50350 zval_ptr_dtor_str(op2);
50351 }
50352 if (result) {
50353 goto is_equal_true;
50354 } else {
50355 goto is_equal_false;
50356 }
50357 }
50358 }
50359 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50360 }
50361
ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50362 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50363 {
50364 USE_OPLINE
50365 zval *op1, *op2;
50366 double d1, d2;
50367
50368 op1 = EX_VAR(opline->op1.var);
50369 op2 = EX_VAR(opline->op2.var);
50370 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50371 /* pass */
50372 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50373 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50374 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
50375 is_equal_true:
50376 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
50377 } else {
50378 is_equal_false:
50379 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
50380 }
50381 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50382 d1 = (double)Z_LVAL_P(op1);
50383 d2 = Z_DVAL_P(op2);
50384 goto is_equal_double;
50385 }
50386 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50387 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50388 d1 = Z_DVAL_P(op1);
50389 d2 = Z_DVAL_P(op2);
50390 is_equal_double:
50391 if (d1 == d2) {
50392 goto is_equal_true;
50393 } else {
50394 goto is_equal_false;
50395 }
50396 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50397 d1 = Z_DVAL_P(op1);
50398 d2 = (double)Z_LVAL_P(op2);
50399 goto is_equal_double;
50400 }
50401 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50402 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50403 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50404 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50405 zval_ptr_dtor_str(op1);
50406 }
50407 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50408 zval_ptr_dtor_str(op2);
50409 }
50410 if (result) {
50411 goto is_equal_true;
50412 } else {
50413 goto is_equal_false;
50414 }
50415 }
50416 }
50417 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50418 }
50419
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50420 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50421 {
50422 USE_OPLINE
50423 zval *op1, *op2;
50424 double d1, d2;
50425
50426 op1 = EX_VAR(opline->op1.var);
50427 op2 = EX_VAR(opline->op2.var);
50428 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50429 /* pass */
50430 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50431 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50432 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
50433 is_not_equal_true:
50434 ZEND_VM_SMART_BRANCH_TRUE_NONE();
50435 } else {
50436 is_not_equal_false:
50437 ZEND_VM_SMART_BRANCH_FALSE_NONE();
50438 }
50439 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50440 d1 = (double)Z_LVAL_P(op1);
50441 d2 = Z_DVAL_P(op2);
50442 goto is_not_equal_double;
50443 }
50444 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50445 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50446 d1 = Z_DVAL_P(op1);
50447 d2 = Z_DVAL_P(op2);
50448 is_not_equal_double:
50449 if (d1 != d2) {
50450 goto is_not_equal_true;
50451 } else {
50452 goto is_not_equal_false;
50453 }
50454 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50455 d1 = Z_DVAL_P(op1);
50456 d2 = (double)Z_LVAL_P(op2);
50457 goto is_not_equal_double;
50458 }
50459 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50460 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50461 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50462 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50463 zval_ptr_dtor_str(op1);
50464 }
50465 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50466 zval_ptr_dtor_str(op2);
50467 }
50468 if (!result) {
50469 goto is_not_equal_true;
50470 } else {
50471 goto is_not_equal_false;
50472 }
50473 }
50474 }
50475 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50476 }
50477
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50478 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50479 {
50480 USE_OPLINE
50481 zval *op1, *op2;
50482 double d1, d2;
50483
50484 op1 = EX_VAR(opline->op1.var);
50485 op2 = EX_VAR(opline->op2.var);
50486 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50487 /* pass */
50488 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50489 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50490 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
50491 is_not_equal_true:
50492 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
50493 } else {
50494 is_not_equal_false:
50495 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
50496 }
50497 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50498 d1 = (double)Z_LVAL_P(op1);
50499 d2 = Z_DVAL_P(op2);
50500 goto is_not_equal_double;
50501 }
50502 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50503 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50504 d1 = Z_DVAL_P(op1);
50505 d2 = Z_DVAL_P(op2);
50506 is_not_equal_double:
50507 if (d1 != d2) {
50508 goto is_not_equal_true;
50509 } else {
50510 goto is_not_equal_false;
50511 }
50512 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50513 d1 = Z_DVAL_P(op1);
50514 d2 = (double)Z_LVAL_P(op2);
50515 goto is_not_equal_double;
50516 }
50517 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50518 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50519 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50520 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50521 zval_ptr_dtor_str(op1);
50522 }
50523 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50524 zval_ptr_dtor_str(op2);
50525 }
50526 if (!result) {
50527 goto is_not_equal_true;
50528 } else {
50529 goto is_not_equal_false;
50530 }
50531 }
50532 }
50533 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50534 }
50535
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50536 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50537 {
50538 USE_OPLINE
50539 zval *op1, *op2;
50540 double d1, d2;
50541
50542 op1 = EX_VAR(opline->op1.var);
50543 op2 = EX_VAR(opline->op2.var);
50544 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50545 /* pass */
50546 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50547 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50548 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
50549 is_not_equal_true:
50550 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
50551 } else {
50552 is_not_equal_false:
50553 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
50554 }
50555 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50556 d1 = (double)Z_LVAL_P(op1);
50557 d2 = Z_DVAL_P(op2);
50558 goto is_not_equal_double;
50559 }
50560 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50561 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50562 d1 = Z_DVAL_P(op1);
50563 d2 = Z_DVAL_P(op2);
50564 is_not_equal_double:
50565 if (d1 != d2) {
50566 goto is_not_equal_true;
50567 } else {
50568 goto is_not_equal_false;
50569 }
50570 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50571 d1 = Z_DVAL_P(op1);
50572 d2 = (double)Z_LVAL_P(op2);
50573 goto is_not_equal_double;
50574 }
50575 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50576 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50577 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50578 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50579 zval_ptr_dtor_str(op1);
50580 }
50581 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50582 zval_ptr_dtor_str(op2);
50583 }
50584 if (!result) {
50585 goto is_not_equal_true;
50586 } else {
50587 goto is_not_equal_false;
50588 }
50589 }
50590 }
50591 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50592 }
50593
ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50594 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50595 {
50596 USE_OPLINE
50597 zval *op1, *op2;
50598
50599 SAVE_OPLINE();
50600 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50601 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50602 compare_function(EX_VAR(opline->result.var), op1, op2);
50603
50604
50605 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50606 }
50607
ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50608 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50609 {
50610 USE_OPLINE
50611 zval *op1, *op2;
50612
50613 SAVE_OPLINE();
50614 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50615 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50616 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
50617
50618
50619 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50620 }
50621
ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50622 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50623 {
50624 USE_OPLINE
50625 zval *object;
50626 zval *property;
50627 zval *value;
50628 zval *zptr;
50629 void **cache_slot;
50630 zend_property_info *prop_info;
50631 zend_object *zobj;
50632 zend_string *name, *tmp_name;
50633
50634 SAVE_OPLINE();
50635 object = EX_VAR(opline->op1.var);
50636 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50637
50638 do {
50639 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
50640
50641 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
50642 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
50643 object = Z_REFVAL_P(object);
50644 goto assign_op_object;
50645 }
50646 if (IS_CV == IS_CV
50647 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
50648 ZVAL_UNDEFINED_OP1();
50649 }
50650 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
50651 break;
50652 }
50653
50654 assign_op_object:
50655 /* here we are sure we are dealing with an object */
50656 zobj = Z_OBJ_P(object);
50657 if (IS_CV == IS_CONST) {
50658 name = Z_STR_P(property);
50659 } else {
50660 name = zval_try_get_tmp_string(property, &tmp_name);
50661 if (UNEXPECTED(!name)) {
50662 UNDEF_RESULT();
50663 break;
50664 }
50665 }
50666 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
50667 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
50668 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
50669 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50670 ZVAL_NULL(EX_VAR(opline->result.var));
50671 }
50672 } else {
50673 zval *orig_zptr = zptr;
50674 zend_reference *ref;
50675
50676 do {
50677 if (UNEXPECTED(Z_ISREF_P(zptr))) {
50678 ref = Z_REF_P(zptr);
50679 zptr = Z_REFVAL_P(zptr);
50680 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
50681 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
50682 break;
50683 }
50684 }
50685
50686 if (IS_CV == IS_CONST) {
50687 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
50688 } else {
50689 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
50690 }
50691 if (prop_info) {
50692 /* special case for typed properties */
50693 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
50694 } else {
50695 zend_binary_op(zptr, zptr, value OPLINE_CC);
50696 }
50697 } while (0);
50698
50699 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50700 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
50701 }
50702 }
50703 } else {
50704 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
50705 }
50706 if (IS_CV != IS_CONST) {
50707 zend_tmp_string_release(tmp_name);
50708 }
50709 } while (0);
50710
50711 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
50712
50713
50714 /* assign_obj has two opcodes! */
50715 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50716 }
50717
50718 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50719 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50720 {
50721 USE_OPLINE
50722 zval *var_ptr;
50723 zval *value, *container, *dim;
50724 HashTable *ht;
50725
50726 SAVE_OPLINE();
50727 container = EX_VAR(opline->op1.var);
50728
50729 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
50730 assign_dim_op_array:
50731 SEPARATE_ARRAY(container);
50732 ht = Z_ARRVAL_P(container);
50733 assign_dim_op_new_array:
50734 dim = EX_VAR(opline->op2.var);
50735 if (IS_CV == IS_UNUSED) {
50736 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
50737 if (UNEXPECTED(!var_ptr)) {
50738 zend_cannot_add_element();
50739 goto assign_dim_op_ret_null;
50740 }
50741 } else {
50742 if (IS_CV == IS_CONST) {
50743 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
50744 } else {
50745 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
50746 }
50747 if (UNEXPECTED(!var_ptr)) {
50748 goto assign_dim_op_ret_null;
50749 }
50750 }
50751
50752 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
50753
50754 do {
50755 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
50756 zend_reference *ref = Z_REF_P(var_ptr);
50757 var_ptr = Z_REFVAL_P(var_ptr);
50758 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
50759 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
50760 break;
50761 }
50762 }
50763 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
50764 } while (0);
50765
50766 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50767 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
50768 }
50769 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
50770 } else {
50771 if (EXPECTED(Z_ISREF_P(container))) {
50772 container = Z_REFVAL_P(container);
50773 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
50774 goto assign_dim_op_array;
50775 }
50776 }
50777
50778 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
50779 zend_object *obj = Z_OBJ_P(container);
50780
50781 dim = EX_VAR(opline->op2.var);
50782 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50783 dim++;
50784 }
50785 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
50786 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
50787 uint8_t old_type;
50788
50789 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
50790 ZVAL_UNDEFINED_OP1();
50791 }
50792 ht = zend_new_array(8);
50793 old_type = Z_TYPE_P(container);
50794 ZVAL_ARR(container, ht);
50795 if (UNEXPECTED(old_type == IS_FALSE)) {
50796 GC_ADDREF(ht);
50797 zend_false_to_array_deprecated();
50798 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50799 zend_array_destroy(ht);
50800 goto assign_dim_op_ret_null;
50801 }
50802 }
50803 goto assign_dim_op_new_array;
50804 } else {
50805 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50806 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
50807 assign_dim_op_ret_null:
50808 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
50809 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50810 ZVAL_NULL(EX_VAR(opline->result.var));
50811 }
50812 }
50813 }
50814
50815
50816 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50817 }
50818
ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50819 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50820 {
50821 USE_OPLINE
50822 zval *var_ptr;
50823 zval *value;
50824
50825 SAVE_OPLINE();
50826 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50827 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
50828
50829 do {
50830 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
50831 zend_reference *ref = Z_REF_P(var_ptr);
50832 var_ptr = Z_REFVAL_P(var_ptr);
50833 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
50834 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
50835 break;
50836 }
50837 }
50838 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
50839 } while (0);
50840
50841 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50842 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
50843 }
50844
50845
50846 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50847 }
50848
ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50849 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50850 {
50851 USE_OPLINE
50852 zval *object;
50853 zval *property;
50854 zval *zptr;
50855 void **cache_slot;
50856 zend_property_info *prop_info;
50857 zend_object *zobj;
50858 zend_string *name, *tmp_name;
50859
50860 SAVE_OPLINE();
50861 object = EX_VAR(opline->op1.var);
50862 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50863
50864 do {
50865 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
50866 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
50867 object = Z_REFVAL_P(object);
50868 goto pre_incdec_object;
50869 }
50870 if (IS_CV == IS_CV
50871 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
50872 ZVAL_UNDEFINED_OP1();
50873 }
50874 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
50875 break;
50876 }
50877
50878 pre_incdec_object:
50879 /* here we are sure we are dealing with an object */
50880 zobj = Z_OBJ_P(object);
50881 if (IS_CV == IS_CONST) {
50882 name = Z_STR_P(property);
50883 } else {
50884 name = zval_try_get_tmp_string(property, &tmp_name);
50885 if (UNEXPECTED(!name)) {
50886 UNDEF_RESULT();
50887 break;
50888 }
50889 }
50890 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
50891 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
50892 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
50893 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50894 ZVAL_NULL(EX_VAR(opline->result.var));
50895 }
50896 } else {
50897 if (IS_CV == IS_CONST) {
50898 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
50899 } else {
50900 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
50901 }
50902 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
50903 }
50904 } else {
50905 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
50906 }
50907 if (IS_CV != IS_CONST) {
50908 zend_tmp_string_release(tmp_name);
50909 }
50910 } while (0);
50911
50912
50913 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50914 }
50915
ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50916 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50917 {
50918 USE_OPLINE
50919 zval *object;
50920 zval *property;
50921 zval *zptr;
50922 void **cache_slot;
50923 zend_property_info *prop_info;
50924 zend_object *zobj;
50925 zend_string *name, *tmp_name;
50926
50927 SAVE_OPLINE();
50928 object = EX_VAR(opline->op1.var);
50929 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50930
50931 do {
50932 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
50933 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
50934 object = Z_REFVAL_P(object);
50935 goto post_incdec_object;
50936 }
50937 if (IS_CV == IS_CV
50938 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
50939 ZVAL_UNDEFINED_OP1();
50940 }
50941 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
50942 break;
50943 }
50944
50945 post_incdec_object:
50946 /* here we are sure we are dealing with an object */
50947 zobj = Z_OBJ_P(object);
50948 if (IS_CV == IS_CONST) {
50949 name = Z_STR_P(property);
50950 } else {
50951 name = zval_try_get_tmp_string(property, &tmp_name);
50952 if (UNEXPECTED(!name)) {
50953 ZVAL_UNDEF(EX_VAR(opline->result.var));
50954 break;
50955 }
50956 }
50957 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
50958 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
50959 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
50960 ZVAL_NULL(EX_VAR(opline->result.var));
50961 } else {
50962 if (IS_CV == IS_CONST) {
50963 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
50964 } else {
50965 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
50966 }
50967
50968 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
50969 }
50970 } else {
50971 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
50972 }
50973 if (IS_CV != IS_CONST) {
50974 zend_tmp_string_release(tmp_name);
50975 }
50976 } while (0);
50977
50978
50979 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50980 }
50981
ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50982 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50983 {
50984 USE_OPLINE
50985 zval *container, *dim, *value;
50986
50987 SAVE_OPLINE();
50988 container = EX_VAR(opline->op1.var);
50989 dim = EX_VAR(opline->op2.var);
50990 if (IS_CV != IS_CONST) {
50991 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
50992 fetch_dim_r_array:
50993 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
50994 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
50995 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
50996 container = Z_REFVAL_P(container);
50997 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
50998 goto fetch_dim_r_array;
50999 } else {
51000 goto fetch_dim_r_slow;
51001 }
51002 } else {
51003 fetch_dim_r_slow:
51004 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
51005 dim++;
51006 }
51007 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
51008 }
51009 } else {
51010 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
51011 }
51012
51013
51014 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51015 }
51016
ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51017 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51018 {
51019 USE_OPLINE
51020 zval *container;
51021
51022 SAVE_OPLINE();
51023 container = EX_VAR(opline->op1.var);
51024 zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
51025
51026 if (IS_CV == IS_VAR) {
51027 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51028 }
51029 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51030 }
51031
ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51032 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51033 {
51034 USE_OPLINE
51035 zval *container;
51036
51037 SAVE_OPLINE();
51038 container = EX_VAR(opline->op1.var);
51039 zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
51040
51041 if (IS_CV == IS_VAR) {
51042 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51043 }
51044 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51045 }
51046
ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51047 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51048 {
51049 USE_OPLINE
51050 zval *container;
51051
51052 SAVE_OPLINE();
51053 container = EX_VAR(opline->op1.var);
51054 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
51055
51056
51057 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51058 }
51059
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51060 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51061 {
51062 #if 0
51063 USE_OPLINE
51064 #endif
51065
51066 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
51067 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
51068 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51069 }
51070 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51071 } else {
51072 if (IS_CV == IS_UNUSED) {
51073 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51074 }
51075 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51076 }
51077 }
51078
ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51079 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51080 {
51081 USE_OPLINE
51082 zval *container;
51083
51084 SAVE_OPLINE();
51085 container = EX_VAR(opline->op1.var);
51086 zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
51087
51088 if (IS_CV == IS_VAR) {
51089 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51090 }
51091 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51092 }
51093
ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51094 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51095 {
51096 USE_OPLINE
51097 zval *container;
51098 void **cache_slot = NULL;
51099
51100 SAVE_OPLINE();
51101 container = EX_VAR(opline->op1.var);
51102
51103 if (IS_CV == IS_CONST ||
51104 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
51105 do {
51106 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
51107 container = Z_REFVAL_P(container);
51108 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
51109 break;
51110 }
51111 }
51112 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
51113 ZVAL_UNDEFINED_OP1();
51114 }
51115 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51116 ZVAL_NULL(EX_VAR(opline->result.var));
51117 goto fetch_obj_r_finish;
51118 } while (0);
51119 }
51120
51121 /* here we are sure we are dealing with an object */
51122 do {
51123 zend_object *zobj = Z_OBJ_P(container);
51124 zend_string *name, *tmp_name;
51125 zval *retval;
51126
51127 if (IS_CV == IS_CONST) {
51128 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
51129
51130 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
51131 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51132
51133 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51134 retval = OBJ_PROP(zobj, prop_offset);
51135 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
51136 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51137 goto fetch_obj_r_copy;
51138 } else {
51139 fetch_obj_r_fast_copy:
51140 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
51141 ZEND_VM_NEXT_OPCODE();
51142 }
51143 }
51144 } else if (EXPECTED(zobj->properties != NULL)) {
51145 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51146 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
51147 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
51148
51149 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
51150 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
51151
51152 if (EXPECTED(p->key == name) ||
51153 (EXPECTED(p->h == ZSTR_H(name)) &&
51154 EXPECTED(p->key != NULL) &&
51155 EXPECTED(zend_string_equal_content(p->key, name)))) {
51156 retval = &p->val;
51157 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51158 goto fetch_obj_r_copy;
51159 } else {
51160 goto fetch_obj_r_fast_copy;
51161 }
51162 }
51163 }
51164 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
51165 }
51166 retval = zend_hash_find_known_hash(zobj->properties, name);
51167 if (EXPECTED(retval)) {
51168 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
51169 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
51170 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51171 goto fetch_obj_r_copy;
51172 } else {
51173 goto fetch_obj_r_fast_copy;
51174 }
51175 }
51176 }
51177 }
51178 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51179 } else {
51180 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51181 if (UNEXPECTED(!name)) {
51182 ZVAL_UNDEF(EX_VAR(opline->result.var));
51183 break;
51184 }
51185 }
51186
51187 #if ZEND_DEBUG
51188 /* For non-standard object handlers, verify a declared property type in debug builds.
51189 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
51190 zend_property_info *prop_info = NULL;
51191 if (zobj->handlers->read_property != zend_std_read_property) {
51192 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
51193 }
51194 #endif
51195 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
51196 #if ZEND_DEBUG
51197 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
51198 && ZEND_TYPE_IS_SET(prop_info->type)) {
51199 ZVAL_OPT_DEREF(retval);
51200 zend_verify_property_type(prop_info, retval, /* strict */ true);
51201 }
51202 #endif
51203
51204 if (IS_CV != IS_CONST) {
51205 zend_tmp_string_release(tmp_name);
51206 }
51207
51208 if (retval != EX_VAR(opline->result.var)) {
51209 fetch_obj_r_copy:
51210 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
51211 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
51212 zend_unwrap_reference(retval);
51213 }
51214 } while (0);
51215
51216 fetch_obj_r_finish:
51217
51218
51219 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51220 }
51221
ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51222 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51223 {
51224 USE_OPLINE
51225 zval *property, *container, *result;
51226
51227 SAVE_OPLINE();
51228
51229 container = EX_VAR(opline->op1.var);
51230 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51231 result = EX_VAR(opline->result.var);
51232 zend_fetch_property_address(
51233 result, container, IS_CV, property, IS_CV,
51234 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
51235 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
51236
51237 if (IS_CV == IS_VAR) {
51238 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51239 }
51240 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51241 }
51242
ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51243 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51244 {
51245 USE_OPLINE
51246 zval *property, *container, *result;
51247
51248 SAVE_OPLINE();
51249 container = EX_VAR(opline->op1.var);
51250 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51251 result = EX_VAR(opline->result.var);
51252 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);
51253
51254 if (IS_CV == IS_VAR) {
51255 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51256 }
51257 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51258 }
51259
ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51260 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51261 {
51262 USE_OPLINE
51263 zval *container;
51264 void **cache_slot = NULL;
51265
51266 SAVE_OPLINE();
51267 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
51268
51269 if (IS_CV == IS_CONST ||
51270 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
51271 do {
51272 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
51273 container = Z_REFVAL_P(container);
51274 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
51275 break;
51276 }
51277 }
51278 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
51279 ZVAL_UNDEFINED_OP2();
51280 }
51281 ZVAL_NULL(EX_VAR(opline->result.var));
51282 goto fetch_obj_is_finish;
51283 } while (0);
51284 }
51285
51286 /* here we are sure we are dealing with an object */
51287 do {
51288 zend_object *zobj = Z_OBJ_P(container);
51289 zend_string *name, *tmp_name;
51290 zval *retval;
51291
51292 if (IS_CV == IS_CONST) {
51293 cache_slot = CACHE_ADDR(opline->extended_value);
51294
51295 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
51296 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51297
51298 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51299 retval = OBJ_PROP(zobj, prop_offset);
51300 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
51301 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51302 goto fetch_obj_is_copy;
51303 } else {
51304 fetch_obj_is_fast_copy:
51305 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
51306 ZEND_VM_NEXT_OPCODE();
51307 }
51308 }
51309 } else if (EXPECTED(zobj->properties != NULL)) {
51310 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51311 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
51312 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
51313
51314 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
51315 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
51316
51317 if (EXPECTED(p->key == name) ||
51318 (EXPECTED(p->h == ZSTR_H(name)) &&
51319 EXPECTED(p->key != NULL) &&
51320 EXPECTED(zend_string_equal_content(p->key, name)))) {
51321 retval = &p->val;
51322 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51323 goto fetch_obj_is_copy;
51324 } else {
51325 goto fetch_obj_is_fast_copy;
51326 }
51327 }
51328 }
51329 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
51330 }
51331 retval = zend_hash_find_known_hash(zobj->properties, name);
51332 if (EXPECTED(retval)) {
51333 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
51334 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
51335 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51336 goto fetch_obj_is_copy;
51337 } else {
51338 goto fetch_obj_is_fast_copy;
51339 }
51340 }
51341 }
51342 }
51343 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51344 } else {
51345 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51346 if (UNEXPECTED(!name)) {
51347 ZVAL_UNDEF(EX_VAR(opline->result.var));
51348 break;
51349 }
51350 }
51351
51352 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
51353
51354 if (IS_CV != IS_CONST) {
51355 zend_tmp_string_release(tmp_name);
51356 }
51357
51358 if (retval != EX_VAR(opline->result.var)) {
51359 fetch_obj_is_copy:
51360 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
51361 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
51362 zend_unwrap_reference(retval);
51363 }
51364 } while (0);
51365
51366 fetch_obj_is_finish:
51367
51368
51369 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51370 }
51371
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51372 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51373 {
51374 #if 0
51375 USE_OPLINE
51376 #endif
51377
51378 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
51379 /* Behave like FETCH_OBJ_W */
51380 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
51381 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51382 }
51383 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51384 } else {
51385 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51386 }
51387 }
51388
ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51389 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51390 {
51391 USE_OPLINE
51392 zval *container, *property, *result;
51393
51394 SAVE_OPLINE();
51395 container = EX_VAR(opline->op1.var);
51396 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51397 result = EX_VAR(opline->result.var);
51398 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);
51399
51400 if (IS_CV == IS_VAR) {
51401 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51402 }
51403 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51404 }
51405
ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51406 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51407 {
51408 USE_OPLINE
51409 zval *object, *value, tmp;
51410 zend_object *zobj;
51411 zend_string *name, *tmp_name;
51412 zend_refcounted *garbage = NULL;
51413
51414 SAVE_OPLINE();
51415 object = EX_VAR(opline->op1.var);
51416 value = RT_CONSTANT((opline+1), (opline+1)->op1);
51417
51418 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
51419 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
51420 object = Z_REFVAL_P(object);
51421 goto assign_object;
51422 }
51423 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
51424 value = &EG(uninitialized_zval);
51425 goto free_and_exit_assign_obj;
51426 }
51427
51428 assign_object:
51429 zobj = Z_OBJ_P(object);
51430 if (IS_CV == IS_CONST) {
51431 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
51432 void **cache_slot = CACHE_ADDR(opline->extended_value);
51433 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51434 zval *property_val;
51435
51436 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51437 property_val = OBJ_PROP(zobj, prop_offset);
51438 if (Z_TYPE_P(property_val) != IS_UNDEF) {
51439 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
51440
51441 if (prop_info != NULL) {
51442 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
51443 goto free_and_exit_assign_obj;
51444 } else {
51445 fast_assign_obj:
51446 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
51447 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51448 ZVAL_COPY(EX_VAR(opline->result.var), value);
51449 }
51450 goto exit_assign_obj;
51451 }
51452 }
51453 } else {
51454 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51455 if (EXPECTED(zobj->properties != NULL)) {
51456 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
51457 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
51458 GC_DELREF(zobj->properties);
51459 }
51460 zobj->properties = zend_array_dup(zobj->properties);
51461 }
51462 property_val = zend_hash_find_known_hash(zobj->properties, name);
51463 if (property_val) {
51464 goto fast_assign_obj;
51465 }
51466 }
51467
51468 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
51469 if (EXPECTED(zobj->properties == NULL)) {
51470 rebuild_object_properties(zobj);
51471 }
51472 if (IS_CONST == IS_CONST) {
51473 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
51474 Z_ADDREF_P(value);
51475 }
51476 } else if (IS_CONST != IS_TMP_VAR) {
51477 if (Z_ISREF_P(value)) {
51478 if (IS_CONST == IS_VAR) {
51479 zend_reference *ref = Z_REF_P(value);
51480 if (GC_DELREF(ref) == 0) {
51481 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
51482 efree_size(ref, sizeof(zend_reference));
51483 value = &tmp;
51484 } else {
51485 value = Z_REFVAL_P(value);
51486 Z_TRY_ADDREF_P(value);
51487 }
51488 } else {
51489 value = Z_REFVAL_P(value);
51490 Z_TRY_ADDREF_P(value);
51491 }
51492 } else if (IS_CONST == IS_CV) {
51493 Z_TRY_ADDREF_P(value);
51494 }
51495 }
51496 zend_hash_add_new(zobj->properties, name, value);
51497 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51498 ZVAL_COPY(EX_VAR(opline->result.var), value);
51499 }
51500 goto exit_assign_obj;
51501 }
51502 }
51503 }
51504 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51505 } else {
51506 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51507 if (UNEXPECTED(!name)) {
51508
51509 UNDEF_RESULT();
51510 goto exit_assign_obj;
51511 }
51512 }
51513
51514 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
51515 ZVAL_DEREF(value);
51516 }
51517
51518 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
51519
51520 if (IS_CV != IS_CONST) {
51521 zend_tmp_string_release(tmp_name);
51522 }
51523
51524 free_and_exit_assign_obj:
51525 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
51526 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
51527 }
51528
51529 exit_assign_obj:
51530 if (garbage) {
51531 GC_DTOR_NO_REF(garbage);
51532 }
51533
51534
51535 /* assign_obj has two opcodes! */
51536 ZEND_VM_NEXT_OPCODE_EX(1, 2);
51537 }
51538
51539 /* 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)51540 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51541 {
51542 USE_OPLINE
51543 zval *object, *value, tmp;
51544 zend_object *zobj;
51545 zend_string *name, *tmp_name;
51546 zend_refcounted *garbage = NULL;
51547
51548 SAVE_OPLINE();
51549 object = EX_VAR(opline->op1.var);
51550 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
51551
51552 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
51553 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
51554 object = Z_REFVAL_P(object);
51555 goto assign_object;
51556 }
51557 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
51558 value = &EG(uninitialized_zval);
51559 goto free_and_exit_assign_obj;
51560 }
51561
51562 assign_object:
51563 zobj = Z_OBJ_P(object);
51564 if (IS_CV == IS_CONST) {
51565 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
51566 void **cache_slot = CACHE_ADDR(opline->extended_value);
51567 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51568 zval *property_val;
51569
51570 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51571 property_val = OBJ_PROP(zobj, prop_offset);
51572 if (Z_TYPE_P(property_val) != IS_UNDEF) {
51573 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
51574
51575 if (prop_info != NULL) {
51576 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
51577 goto free_and_exit_assign_obj;
51578 } else {
51579 fast_assign_obj:
51580 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
51581 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51582 ZVAL_COPY(EX_VAR(opline->result.var), value);
51583 }
51584 goto exit_assign_obj;
51585 }
51586 }
51587 } else {
51588 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51589 if (EXPECTED(zobj->properties != NULL)) {
51590 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
51591 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
51592 GC_DELREF(zobj->properties);
51593 }
51594 zobj->properties = zend_array_dup(zobj->properties);
51595 }
51596 property_val = zend_hash_find_known_hash(zobj->properties, name);
51597 if (property_val) {
51598 goto fast_assign_obj;
51599 }
51600 }
51601
51602 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
51603 if (EXPECTED(zobj->properties == NULL)) {
51604 rebuild_object_properties(zobj);
51605 }
51606 if (IS_TMP_VAR == IS_CONST) {
51607 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
51608 Z_ADDREF_P(value);
51609 }
51610 } else if (IS_TMP_VAR != IS_TMP_VAR) {
51611 if (Z_ISREF_P(value)) {
51612 if (IS_TMP_VAR == IS_VAR) {
51613 zend_reference *ref = Z_REF_P(value);
51614 if (GC_DELREF(ref) == 0) {
51615 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
51616 efree_size(ref, sizeof(zend_reference));
51617 value = &tmp;
51618 } else {
51619 value = Z_REFVAL_P(value);
51620 Z_TRY_ADDREF_P(value);
51621 }
51622 } else {
51623 value = Z_REFVAL_P(value);
51624 Z_TRY_ADDREF_P(value);
51625 }
51626 } else if (IS_TMP_VAR == IS_CV) {
51627 Z_TRY_ADDREF_P(value);
51628 }
51629 }
51630 zend_hash_add_new(zobj->properties, name, value);
51631 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51632 ZVAL_COPY(EX_VAR(opline->result.var), value);
51633 }
51634 goto exit_assign_obj;
51635 }
51636 }
51637 }
51638 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51639 } else {
51640 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51641 if (UNEXPECTED(!name)) {
51642 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
51643 UNDEF_RESULT();
51644 goto exit_assign_obj;
51645 }
51646 }
51647
51648 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
51649 ZVAL_DEREF(value);
51650 }
51651
51652 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
51653
51654 if (IS_CV != IS_CONST) {
51655 zend_tmp_string_release(tmp_name);
51656 }
51657
51658 free_and_exit_assign_obj:
51659 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
51660 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
51661 }
51662 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
51663 exit_assign_obj:
51664 if (garbage) {
51665 GC_DTOR_NO_REF(garbage);
51666 }
51667
51668
51669 /* assign_obj has two opcodes! */
51670 ZEND_VM_NEXT_OPCODE_EX(1, 2);
51671 }
51672
51673 /* 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)51674 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51675 {
51676 USE_OPLINE
51677 zval *object, *value, tmp;
51678 zend_object *zobj;
51679 zend_string *name, *tmp_name;
51680 zend_refcounted *garbage = NULL;
51681
51682 SAVE_OPLINE();
51683 object = EX_VAR(opline->op1.var);
51684 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
51685
51686 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
51687 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
51688 object = Z_REFVAL_P(object);
51689 goto assign_object;
51690 }
51691 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
51692 value = &EG(uninitialized_zval);
51693 goto free_and_exit_assign_obj;
51694 }
51695
51696 assign_object:
51697 zobj = Z_OBJ_P(object);
51698 if (IS_CV == IS_CONST) {
51699 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
51700 void **cache_slot = CACHE_ADDR(opline->extended_value);
51701 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51702 zval *property_val;
51703
51704 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51705 property_val = OBJ_PROP(zobj, prop_offset);
51706 if (Z_TYPE_P(property_val) != IS_UNDEF) {
51707 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
51708
51709 if (prop_info != NULL) {
51710 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
51711 goto free_and_exit_assign_obj;
51712 } else {
51713 fast_assign_obj:
51714 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
51715 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51716 ZVAL_COPY(EX_VAR(opline->result.var), value);
51717 }
51718 goto exit_assign_obj;
51719 }
51720 }
51721 } else {
51722 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51723 if (EXPECTED(zobj->properties != NULL)) {
51724 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
51725 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
51726 GC_DELREF(zobj->properties);
51727 }
51728 zobj->properties = zend_array_dup(zobj->properties);
51729 }
51730 property_val = zend_hash_find_known_hash(zobj->properties, name);
51731 if (property_val) {
51732 goto fast_assign_obj;
51733 }
51734 }
51735
51736 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
51737 if (EXPECTED(zobj->properties == NULL)) {
51738 rebuild_object_properties(zobj);
51739 }
51740 if (IS_VAR == IS_CONST) {
51741 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
51742 Z_ADDREF_P(value);
51743 }
51744 } else if (IS_VAR != IS_TMP_VAR) {
51745 if (Z_ISREF_P(value)) {
51746 if (IS_VAR == IS_VAR) {
51747 zend_reference *ref = Z_REF_P(value);
51748 if (GC_DELREF(ref) == 0) {
51749 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
51750 efree_size(ref, sizeof(zend_reference));
51751 value = &tmp;
51752 } else {
51753 value = Z_REFVAL_P(value);
51754 Z_TRY_ADDREF_P(value);
51755 }
51756 } else {
51757 value = Z_REFVAL_P(value);
51758 Z_TRY_ADDREF_P(value);
51759 }
51760 } else if (IS_VAR == IS_CV) {
51761 Z_TRY_ADDREF_P(value);
51762 }
51763 }
51764 zend_hash_add_new(zobj->properties, name, value);
51765 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51766 ZVAL_COPY(EX_VAR(opline->result.var), value);
51767 }
51768 goto exit_assign_obj;
51769 }
51770 }
51771 }
51772 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51773 } else {
51774 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51775 if (UNEXPECTED(!name)) {
51776 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
51777 UNDEF_RESULT();
51778 goto exit_assign_obj;
51779 }
51780 }
51781
51782 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
51783 ZVAL_DEREF(value);
51784 }
51785
51786 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
51787
51788 if (IS_CV != IS_CONST) {
51789 zend_tmp_string_release(tmp_name);
51790 }
51791
51792 free_and_exit_assign_obj:
51793 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
51794 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
51795 }
51796 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
51797 exit_assign_obj:
51798 if (garbage) {
51799 GC_DTOR_NO_REF(garbage);
51800 }
51801
51802
51803 /* assign_obj has two opcodes! */
51804 ZEND_VM_NEXT_OPCODE_EX(1, 2);
51805 }
51806
51807 /* 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)51808 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51809 {
51810 USE_OPLINE
51811 zval *object, *value, tmp;
51812 zend_object *zobj;
51813 zend_string *name, *tmp_name;
51814 zend_refcounted *garbage = NULL;
51815
51816 SAVE_OPLINE();
51817 object = EX_VAR(opline->op1.var);
51818 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
51819
51820 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
51821 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
51822 object = Z_REFVAL_P(object);
51823 goto assign_object;
51824 }
51825 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
51826 value = &EG(uninitialized_zval);
51827 goto free_and_exit_assign_obj;
51828 }
51829
51830 assign_object:
51831 zobj = Z_OBJ_P(object);
51832 if (IS_CV == IS_CONST) {
51833 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
51834 void **cache_slot = CACHE_ADDR(opline->extended_value);
51835 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51836 zval *property_val;
51837
51838 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51839 property_val = OBJ_PROP(zobj, prop_offset);
51840 if (Z_TYPE_P(property_val) != IS_UNDEF) {
51841 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
51842
51843 if (prop_info != NULL) {
51844 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
51845 goto free_and_exit_assign_obj;
51846 } else {
51847 fast_assign_obj:
51848 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
51849 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51850 ZVAL_COPY(EX_VAR(opline->result.var), value);
51851 }
51852 goto exit_assign_obj;
51853 }
51854 }
51855 } else {
51856 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51857 if (EXPECTED(zobj->properties != NULL)) {
51858 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
51859 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
51860 GC_DELREF(zobj->properties);
51861 }
51862 zobj->properties = zend_array_dup(zobj->properties);
51863 }
51864 property_val = zend_hash_find_known_hash(zobj->properties, name);
51865 if (property_val) {
51866 goto fast_assign_obj;
51867 }
51868 }
51869
51870 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
51871 if (EXPECTED(zobj->properties == NULL)) {
51872 rebuild_object_properties(zobj);
51873 }
51874 if (IS_CV == IS_CONST) {
51875 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
51876 Z_ADDREF_P(value);
51877 }
51878 } else if (IS_CV != IS_TMP_VAR) {
51879 if (Z_ISREF_P(value)) {
51880 if (IS_CV == IS_VAR) {
51881 zend_reference *ref = Z_REF_P(value);
51882 if (GC_DELREF(ref) == 0) {
51883 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
51884 efree_size(ref, sizeof(zend_reference));
51885 value = &tmp;
51886 } else {
51887 value = Z_REFVAL_P(value);
51888 Z_TRY_ADDREF_P(value);
51889 }
51890 } else {
51891 value = Z_REFVAL_P(value);
51892 Z_TRY_ADDREF_P(value);
51893 }
51894 } else if (IS_CV == IS_CV) {
51895 Z_TRY_ADDREF_P(value);
51896 }
51897 }
51898 zend_hash_add_new(zobj->properties, name, value);
51899 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51900 ZVAL_COPY(EX_VAR(opline->result.var), value);
51901 }
51902 goto exit_assign_obj;
51903 }
51904 }
51905 }
51906 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51907 } else {
51908 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51909 if (UNEXPECTED(!name)) {
51910
51911 UNDEF_RESULT();
51912 goto exit_assign_obj;
51913 }
51914 }
51915
51916 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
51917 ZVAL_DEREF(value);
51918 }
51919
51920 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
51921
51922 if (IS_CV != IS_CONST) {
51923 zend_tmp_string_release(tmp_name);
51924 }
51925
51926 free_and_exit_assign_obj:
51927 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
51928 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
51929 }
51930
51931 exit_assign_obj:
51932 if (garbage) {
51933 GC_DTOR_NO_REF(garbage);
51934 }
51935
51936
51937 /* assign_obj has two opcodes! */
51938 ZEND_VM_NEXT_OPCODE_EX(1, 2);
51939 }
51940
51941 /* 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)51942 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51943 {
51944 USE_OPLINE
51945 zval *object_ptr, *orig_object_ptr;
51946 zval *value;
51947 zval *variable_ptr;
51948 zval *dim;
51949 zend_refcounted *garbage = NULL;
51950
51951 SAVE_OPLINE();
51952 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
51953
51954 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
51955 try_assign_dim_array:
51956 SEPARATE_ARRAY(object_ptr);
51957 if (IS_CV == IS_UNUSED) {
51958 value = RT_CONSTANT((opline+1), (opline+1)->op1);
51959 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
51960 HashTable *ht = Z_ARRVAL_P(object_ptr);
51961 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
51962 GC_ADDREF(ht);
51963 }
51964 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
51965 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
51966 zend_array_destroy(ht);
51967 goto assign_dim_error;
51968 }
51969 }
51970 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
51971 ZVAL_DEREF(value);
51972 }
51973 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
51974 if (UNEXPECTED(value == NULL)) {
51975 zend_cannot_add_element();
51976 goto assign_dim_error;
51977 } else if (IS_CONST == IS_CV) {
51978 if (Z_REFCOUNTED_P(value)) {
51979 Z_ADDREF_P(value);
51980 }
51981 } else if (IS_CONST == IS_VAR) {
51982 zval *free_op_data = EX_VAR((opline+1)->op1.var);
51983 if (Z_ISREF_P(free_op_data)) {
51984 if (Z_REFCOUNTED_P(value)) {
51985 Z_ADDREF_P(value);
51986 }
51987 zval_ptr_dtor_nogc(free_op_data);
51988 }
51989 } else if (IS_CONST == IS_CONST) {
51990 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
51991 Z_ADDREF_P(value);
51992 }
51993 }
51994 } else {
51995 dim = EX_VAR(opline->op2.var);
51996 if (IS_CV == IS_CONST) {
51997 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
51998 } else {
51999 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52000 }
52001 if (UNEXPECTED(variable_ptr == NULL)) {
52002 goto assign_dim_error;
52003 }
52004 value = RT_CONSTANT((opline+1), (opline+1)->op1);
52005 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
52006 }
52007 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52008 ZVAL_COPY(EX_VAR(opline->result.var), value);
52009 }
52010 if (garbage) {
52011 GC_DTOR_NO_REF(garbage);
52012 }
52013 } else {
52014 if (EXPECTED(Z_ISREF_P(object_ptr))) {
52015 object_ptr = Z_REFVAL_P(object_ptr);
52016 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52017 goto try_assign_dim_array;
52018 }
52019 }
52020 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
52021 zend_object *obj = Z_OBJ_P(object_ptr);
52022
52023 GC_ADDREF(obj);
52024 dim = EX_VAR(opline->op2.var);
52025 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
52026 dim = ZVAL_UNDEFINED_OP2();
52027 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52028 dim++;
52029 }
52030
52031 value = RT_CONSTANT((opline+1), (opline+1)->op1);
52032 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
52033 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52034 } else if (IS_CONST & (IS_CV|IS_VAR)) {
52035 ZVAL_DEREF(value);
52036 }
52037
52038 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
52039
52040 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
52041 zend_objects_store_del(obj);
52042 }
52043 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
52044 if (IS_CV == IS_UNUSED) {
52045 zend_use_new_element_for_string();
52046
52047 UNDEF_RESULT();
52048 } else {
52049 dim = EX_VAR(opline->op2.var);
52050 value = RT_CONSTANT((opline+1), (opline+1)->op1);
52051 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
52052
52053 }
52054 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
52055 if (Z_ISREF_P(orig_object_ptr)
52056 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
52057 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
52058 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52059
52060 UNDEF_RESULT();
52061 } else {
52062 HashTable *ht = zend_new_array(8);
52063 uint8_t old_type = Z_TYPE_P(object_ptr);
52064
52065 ZVAL_ARR(object_ptr, ht);
52066 if (UNEXPECTED(old_type == IS_FALSE)) {
52067 GC_ADDREF(ht);
52068 zend_false_to_array_deprecated();
52069 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52070 zend_array_destroy(ht);
52071 goto assign_dim_error;
52072 }
52073 }
52074 goto try_assign_dim_array;
52075 }
52076 } else {
52077 zend_use_scalar_as_array();
52078 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52079 assign_dim_error:
52080
52081 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52082 ZVAL_NULL(EX_VAR(opline->result.var));
52083 }
52084 }
52085 }
52086 if (IS_CV != IS_UNUSED) {
52087
52088 }
52089
52090 /* assign_dim has two opcodes! */
52091 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52092 }
52093
ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52094 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52095 {
52096 USE_OPLINE
52097 zval *object_ptr, *orig_object_ptr;
52098 zval *value;
52099 zval *variable_ptr;
52100 zval *dim;
52101 zend_refcounted *garbage = NULL;
52102
52103 SAVE_OPLINE();
52104 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
52105
52106 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52107 try_assign_dim_array:
52108 SEPARATE_ARRAY(object_ptr);
52109 if (IS_CV == IS_UNUSED) {
52110 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
52111 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
52112 HashTable *ht = Z_ARRVAL_P(object_ptr);
52113 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
52114 GC_ADDREF(ht);
52115 }
52116 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52117 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
52118 zend_array_destroy(ht);
52119 goto assign_dim_error;
52120 }
52121 }
52122 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
52123 ZVAL_DEREF(value);
52124 }
52125 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
52126 if (UNEXPECTED(value == NULL)) {
52127 zend_cannot_add_element();
52128 goto assign_dim_error;
52129 } else if (IS_TMP_VAR == IS_CV) {
52130 if (Z_REFCOUNTED_P(value)) {
52131 Z_ADDREF_P(value);
52132 }
52133 } else if (IS_TMP_VAR == IS_VAR) {
52134 zval *free_op_data = EX_VAR((opline+1)->op1.var);
52135 if (Z_ISREF_P(free_op_data)) {
52136 if (Z_REFCOUNTED_P(value)) {
52137 Z_ADDREF_P(value);
52138 }
52139 zval_ptr_dtor_nogc(free_op_data);
52140 }
52141 } else if (IS_TMP_VAR == IS_CONST) {
52142 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
52143 Z_ADDREF_P(value);
52144 }
52145 }
52146 } else {
52147 dim = EX_VAR(opline->op2.var);
52148 if (IS_CV == IS_CONST) {
52149 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52150 } else {
52151 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52152 }
52153 if (UNEXPECTED(variable_ptr == NULL)) {
52154 goto assign_dim_error;
52155 }
52156 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
52157 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
52158 }
52159 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52160 ZVAL_COPY(EX_VAR(opline->result.var), value);
52161 }
52162 if (garbage) {
52163 GC_DTOR_NO_REF(garbage);
52164 }
52165 } else {
52166 if (EXPECTED(Z_ISREF_P(object_ptr))) {
52167 object_ptr = Z_REFVAL_P(object_ptr);
52168 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52169 goto try_assign_dim_array;
52170 }
52171 }
52172 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
52173 zend_object *obj = Z_OBJ_P(object_ptr);
52174
52175 GC_ADDREF(obj);
52176 dim = EX_VAR(opline->op2.var);
52177 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
52178 dim = ZVAL_UNDEFINED_OP2();
52179 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52180 dim++;
52181 }
52182
52183 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
52184 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
52185 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52186 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
52187 ZVAL_DEREF(value);
52188 }
52189
52190 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
52191
52192 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52193 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
52194 zend_objects_store_del(obj);
52195 }
52196 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
52197 if (IS_CV == IS_UNUSED) {
52198 zend_use_new_element_for_string();
52199 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52200 UNDEF_RESULT();
52201 } else {
52202 dim = EX_VAR(opline->op2.var);
52203 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
52204 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
52205 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52206 }
52207 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
52208 if (Z_ISREF_P(orig_object_ptr)
52209 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
52210 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
52211 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52212 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52213 UNDEF_RESULT();
52214 } else {
52215 HashTable *ht = zend_new_array(8);
52216 uint8_t old_type = Z_TYPE_P(object_ptr);
52217
52218 ZVAL_ARR(object_ptr, ht);
52219 if (UNEXPECTED(old_type == IS_FALSE)) {
52220 GC_ADDREF(ht);
52221 zend_false_to_array_deprecated();
52222 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52223 zend_array_destroy(ht);
52224 goto assign_dim_error;
52225 }
52226 }
52227 goto try_assign_dim_array;
52228 }
52229 } else {
52230 zend_use_scalar_as_array();
52231 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52232 assign_dim_error:
52233 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52234 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52235 ZVAL_NULL(EX_VAR(opline->result.var));
52236 }
52237 }
52238 }
52239 if (IS_CV != IS_UNUSED) {
52240
52241 }
52242
52243 /* assign_dim has two opcodes! */
52244 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52245 }
52246
ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52247 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52248 {
52249 USE_OPLINE
52250 zval *object_ptr, *orig_object_ptr;
52251 zval *value;
52252 zval *variable_ptr;
52253 zval *dim;
52254 zend_refcounted *garbage = NULL;
52255
52256 SAVE_OPLINE();
52257 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
52258
52259 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52260 try_assign_dim_array:
52261 SEPARATE_ARRAY(object_ptr);
52262 if (IS_CV == IS_UNUSED) {
52263 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
52264 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
52265 HashTable *ht = Z_ARRVAL_P(object_ptr);
52266 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
52267 GC_ADDREF(ht);
52268 }
52269 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52270 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
52271 zend_array_destroy(ht);
52272 goto assign_dim_error;
52273 }
52274 }
52275 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
52276 ZVAL_DEREF(value);
52277 }
52278 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
52279 if (UNEXPECTED(value == NULL)) {
52280 zend_cannot_add_element();
52281 goto assign_dim_error;
52282 } else if (IS_VAR == IS_CV) {
52283 if (Z_REFCOUNTED_P(value)) {
52284 Z_ADDREF_P(value);
52285 }
52286 } else if (IS_VAR == IS_VAR) {
52287 zval *free_op_data = EX_VAR((opline+1)->op1.var);
52288 if (Z_ISREF_P(free_op_data)) {
52289 if (Z_REFCOUNTED_P(value)) {
52290 Z_ADDREF_P(value);
52291 }
52292 zval_ptr_dtor_nogc(free_op_data);
52293 }
52294 } else if (IS_VAR == IS_CONST) {
52295 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
52296 Z_ADDREF_P(value);
52297 }
52298 }
52299 } else {
52300 dim = EX_VAR(opline->op2.var);
52301 if (IS_CV == IS_CONST) {
52302 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52303 } else {
52304 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52305 }
52306 if (UNEXPECTED(variable_ptr == NULL)) {
52307 goto assign_dim_error;
52308 }
52309 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
52310 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
52311 }
52312 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52313 ZVAL_COPY(EX_VAR(opline->result.var), value);
52314 }
52315 if (garbage) {
52316 GC_DTOR_NO_REF(garbage);
52317 }
52318 } else {
52319 if (EXPECTED(Z_ISREF_P(object_ptr))) {
52320 object_ptr = Z_REFVAL_P(object_ptr);
52321 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52322 goto try_assign_dim_array;
52323 }
52324 }
52325 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
52326 zend_object *obj = Z_OBJ_P(object_ptr);
52327
52328 GC_ADDREF(obj);
52329 dim = EX_VAR(opline->op2.var);
52330 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
52331 dim = ZVAL_UNDEFINED_OP2();
52332 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52333 dim++;
52334 }
52335
52336 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
52337 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
52338 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52339 } else if (IS_VAR & (IS_CV|IS_VAR)) {
52340 ZVAL_DEREF(value);
52341 }
52342
52343 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
52344
52345 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52346 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
52347 zend_objects_store_del(obj);
52348 }
52349 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
52350 if (IS_CV == IS_UNUSED) {
52351 zend_use_new_element_for_string();
52352 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52353 UNDEF_RESULT();
52354 } else {
52355 dim = EX_VAR(opline->op2.var);
52356 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
52357 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
52358 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52359 }
52360 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
52361 if (Z_ISREF_P(orig_object_ptr)
52362 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
52363 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
52364 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52365 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52366 UNDEF_RESULT();
52367 } else {
52368 HashTable *ht = zend_new_array(8);
52369 uint8_t old_type = Z_TYPE_P(object_ptr);
52370
52371 ZVAL_ARR(object_ptr, ht);
52372 if (UNEXPECTED(old_type == IS_FALSE)) {
52373 GC_ADDREF(ht);
52374 zend_false_to_array_deprecated();
52375 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52376 zend_array_destroy(ht);
52377 goto assign_dim_error;
52378 }
52379 }
52380 goto try_assign_dim_array;
52381 }
52382 } else {
52383 zend_use_scalar_as_array();
52384 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52385 assign_dim_error:
52386 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52387 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52388 ZVAL_NULL(EX_VAR(opline->result.var));
52389 }
52390 }
52391 }
52392 if (IS_CV != IS_UNUSED) {
52393
52394 }
52395
52396 /* assign_dim has two opcodes! */
52397 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52398 }
52399
ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52400 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52401 {
52402 USE_OPLINE
52403 zval *object_ptr, *orig_object_ptr;
52404 zval *value;
52405 zval *variable_ptr;
52406 zval *dim;
52407 zend_refcounted *garbage = NULL;
52408
52409 SAVE_OPLINE();
52410 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
52411
52412 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52413 try_assign_dim_array:
52414 SEPARATE_ARRAY(object_ptr);
52415 if (IS_CV == IS_UNUSED) {
52416 value = EX_VAR((opline+1)->op1.var);
52417 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
52418 HashTable *ht = Z_ARRVAL_P(object_ptr);
52419 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
52420 GC_ADDREF(ht);
52421 }
52422 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52423 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
52424 zend_array_destroy(ht);
52425 goto assign_dim_error;
52426 }
52427 }
52428 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
52429 ZVAL_DEREF(value);
52430 }
52431 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
52432 if (UNEXPECTED(value == NULL)) {
52433 zend_cannot_add_element();
52434 goto assign_dim_error;
52435 } else if (IS_CV == IS_CV) {
52436 if (Z_REFCOUNTED_P(value)) {
52437 Z_ADDREF_P(value);
52438 }
52439 } else if (IS_CV == IS_VAR) {
52440 zval *free_op_data = EX_VAR((opline+1)->op1.var);
52441 if (Z_ISREF_P(free_op_data)) {
52442 if (Z_REFCOUNTED_P(value)) {
52443 Z_ADDREF_P(value);
52444 }
52445 zval_ptr_dtor_nogc(free_op_data);
52446 }
52447 } else if (IS_CV == IS_CONST) {
52448 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
52449 Z_ADDREF_P(value);
52450 }
52451 }
52452 } else {
52453 dim = EX_VAR(opline->op2.var);
52454 if (IS_CV == IS_CONST) {
52455 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52456 } else {
52457 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52458 }
52459 if (UNEXPECTED(variable_ptr == NULL)) {
52460 goto assign_dim_error;
52461 }
52462 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
52463 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
52464 }
52465 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52466 ZVAL_COPY(EX_VAR(opline->result.var), value);
52467 }
52468 if (garbage) {
52469 GC_DTOR_NO_REF(garbage);
52470 }
52471 } else {
52472 if (EXPECTED(Z_ISREF_P(object_ptr))) {
52473 object_ptr = Z_REFVAL_P(object_ptr);
52474 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52475 goto try_assign_dim_array;
52476 }
52477 }
52478 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
52479 zend_object *obj = Z_OBJ_P(object_ptr);
52480
52481 GC_ADDREF(obj);
52482 dim = EX_VAR(opline->op2.var);
52483 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
52484 dim = ZVAL_UNDEFINED_OP2();
52485 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52486 dim++;
52487 }
52488
52489 value = EX_VAR((opline+1)->op1.var);
52490 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
52491 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52492 } else if (IS_CV & (IS_CV|IS_VAR)) {
52493 ZVAL_DEREF(value);
52494 }
52495
52496 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
52497
52498 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
52499 zend_objects_store_del(obj);
52500 }
52501 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
52502 if (IS_CV == IS_UNUSED) {
52503 zend_use_new_element_for_string();
52504
52505 UNDEF_RESULT();
52506 } else {
52507 dim = EX_VAR(opline->op2.var);
52508 value = EX_VAR((opline+1)->op1.var);
52509 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
52510
52511 }
52512 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
52513 if (Z_ISREF_P(orig_object_ptr)
52514 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
52515 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
52516 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52517
52518 UNDEF_RESULT();
52519 } else {
52520 HashTable *ht = zend_new_array(8);
52521 uint8_t old_type = Z_TYPE_P(object_ptr);
52522
52523 ZVAL_ARR(object_ptr, ht);
52524 if (UNEXPECTED(old_type == IS_FALSE)) {
52525 GC_ADDREF(ht);
52526 zend_false_to_array_deprecated();
52527 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52528 zend_array_destroy(ht);
52529 goto assign_dim_error;
52530 }
52531 }
52532 goto try_assign_dim_array;
52533 }
52534 } else {
52535 zend_use_scalar_as_array();
52536 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52537 assign_dim_error:
52538
52539 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52540 ZVAL_NULL(EX_VAR(opline->result.var));
52541 }
52542 }
52543 }
52544 if (IS_CV != IS_UNUSED) {
52545
52546 }
52547
52548 /* assign_dim has two opcodes! */
52549 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52550 }
52551
ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52552 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52553 {
52554 USE_OPLINE
52555 zval *value;
52556 zval *variable_ptr;
52557
52558 SAVE_OPLINE();
52559 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52560 variable_ptr = EX_VAR(opline->op1.var);
52561
52562 if (0 || UNEXPECTED(0)) {
52563 zend_refcounted *garbage = NULL;
52564
52565 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
52566 if (UNEXPECTED(0)) {
52567 ZVAL_COPY(EX_VAR(opline->result.var), value);
52568 }
52569 if (garbage) {
52570 GC_DTOR_NO_REF(garbage);
52571 }
52572 } else {
52573 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
52574 }
52575
52576 /* zend_assign_to_variable() always takes care of op2, never free it! */
52577
52578 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52579 }
52580
ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52581 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52582 {
52583 USE_OPLINE
52584 zval *value;
52585 zval *variable_ptr;
52586
52587 SAVE_OPLINE();
52588 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52589 variable_ptr = EX_VAR(opline->op1.var);
52590
52591 if (0 || UNEXPECTED(1)) {
52592 zend_refcounted *garbage = NULL;
52593
52594 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
52595 if (UNEXPECTED(1)) {
52596 ZVAL_COPY(EX_VAR(opline->result.var), value);
52597 }
52598 if (garbage) {
52599 GC_DTOR_NO_REF(garbage);
52600 }
52601 } else {
52602 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
52603 }
52604
52605 /* zend_assign_to_variable() always takes care of op2, never free it! */
52606
52607 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52608 }
52609
ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52610 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52611 {
52612 USE_OPLINE
52613 zval *variable_ptr;
52614 zval *value_ptr;
52615 zend_refcounted *garbage = NULL;
52616
52617 SAVE_OPLINE();
52618 value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
52619 variable_ptr = EX_VAR(opline->op1.var);
52620
52621 if (IS_CV == IS_VAR &&
52622 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
52623
52624 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
52625 variable_ptr = &EG(uninitialized_zval);
52626 } else if (IS_CV == IS_VAR &&
52627 opline->extended_value == ZEND_RETURNS_FUNCTION &&
52628 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
52629
52630 variable_ptr = zend_wrong_assign_to_variable_reference(
52631 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
52632 } else {
52633 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
52634 }
52635
52636 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52637 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
52638 }
52639
52640 if (garbage) {
52641 GC_DTOR(garbage);
52642 }
52643
52644
52645 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52646 }
52647
ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52648 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52649 {
52650 USE_OPLINE
52651 zval *property, *container, *value_ptr;
52652
52653 SAVE_OPLINE();
52654
52655 container = EX_VAR(opline->op1.var);
52656 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52657
52658 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
52659
52660 if (1) {
52661 if (IS_CV == IS_UNUSED) {
52662 if (IS_CV == IS_CONST) {
52663 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52664 } else {
52665 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52666 }
52667 } else {
52668 if (IS_CV == IS_CONST) {
52669 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52670 } else {
52671 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52672 }
52673 }
52674 } else {
52675 zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52676 }
52677
52678
52679 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52680 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52681 }
52682
52683 /* 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)52684 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52685 {
52686 USE_OPLINE
52687 zval *property, *container, *value_ptr;
52688
52689 SAVE_OPLINE();
52690
52691 container = EX_VAR(opline->op1.var);
52692 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52693
52694 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
52695
52696 if (1) {
52697 if (IS_CV == IS_UNUSED) {
52698 if (IS_CV == IS_CONST) {
52699 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52700 } else {
52701 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52702 }
52703 } else {
52704 if (IS_CV == IS_CONST) {
52705 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52706 } else {
52707 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52708 }
52709 }
52710 } else {
52711 zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52712 }
52713
52714
52715
52716 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52717 }
52718
52719 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52720 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52721 {
52722 USE_OPLINE
52723 zval *op1, *op2;
52724 zend_string *op1_str, *op2_str, *str;
52725
52726
52727 op1 = EX_VAR(opline->op1.var);
52728 op2 = EX_VAR(opline->op2.var);
52729 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
52730 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
52731 zend_string *op1_str = Z_STR_P(op1);
52732 zend_string *op2_str = Z_STR_P(op2);
52733 zend_string *str;
52734 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
52735
52736 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
52737 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
52738 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
52739 } else {
52740 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
52741 }
52742 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52743 zend_string_release_ex(op1_str, 0);
52744 }
52745 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
52746 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
52747 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
52748 } else {
52749 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
52750 }
52751 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52752 zend_string_release_ex(op2_str, 0);
52753 }
52754 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
52755 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
52756 size_t len = ZSTR_LEN(op1_str);
52757
52758 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
52759 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
52760 GC_ADD_FLAGS(str, flags);
52761 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
52762 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52763 zend_string_release_ex(op2_str, 0);
52764 }
52765 } else {
52766 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
52767 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
52768 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
52769 GC_ADD_FLAGS(str, flags);
52770 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
52771 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52772 zend_string_release_ex(op1_str, 0);
52773 }
52774 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52775 zend_string_release_ex(op2_str, 0);
52776 }
52777 }
52778 ZEND_VM_NEXT_OPCODE();
52779 }
52780
52781 SAVE_OPLINE();
52782 if (IS_CV == IS_CONST) {
52783 op1_str = Z_STR_P(op1);
52784 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
52785 op1_str = zend_string_copy(Z_STR_P(op1));
52786 } else {
52787 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
52788 ZVAL_UNDEFINED_OP1();
52789 }
52790 op1_str = zval_get_string_func(op1);
52791 }
52792 if (IS_CV == IS_CONST) {
52793 op2_str = Z_STR_P(op2);
52794 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
52795 op2_str = zend_string_copy(Z_STR_P(op2));
52796 } else {
52797 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
52798 ZVAL_UNDEFINED_OP2();
52799 }
52800 op2_str = zval_get_string_func(op2);
52801 }
52802 do {
52803 if (IS_CV != IS_CONST) {
52804 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
52805 if (IS_CV == IS_CONST) {
52806 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
52807 GC_ADDREF(op2_str);
52808 }
52809 }
52810 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
52811 zend_string_release_ex(op1_str, 0);
52812 break;
52813 }
52814 }
52815 if (IS_CV != IS_CONST) {
52816 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
52817 if (IS_CV == IS_CONST) {
52818 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
52819 GC_ADDREF(op1_str);
52820 }
52821 }
52822 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
52823 zend_string_release_ex(op2_str, 0);
52824 break;
52825 }
52826 }
52827 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
52828 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
52829 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
52830
52831 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
52832 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
52833 if (IS_CV != IS_CONST) {
52834 zend_string_release_ex(op1_str, 0);
52835 }
52836 if (IS_CV != IS_CONST) {
52837 zend_string_release_ex(op2_str, 0);
52838 }
52839 } while (0);
52840
52841
52842 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52843 }
52844
ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52845 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52846 {
52847 USE_OPLINE
52848 zval *function_name;
52849 zval *object;
52850 zend_function *fbc;
52851 zend_class_entry *called_scope;
52852 zend_object *obj;
52853 zend_execute_data *call;
52854 uint32_t call_info;
52855
52856 SAVE_OPLINE();
52857
52858 object = EX_VAR(opline->op1.var);
52859
52860 if (IS_CV != IS_CONST) {
52861 function_name = EX_VAR(opline->op2.var);
52862 }
52863
52864 if (IS_CV != IS_CONST &&
52865 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
52866 do {
52867 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
52868 function_name = Z_REFVAL_P(function_name);
52869 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
52870 break;
52871 }
52872 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
52873 ZVAL_UNDEFINED_OP2();
52874 if (UNEXPECTED(EG(exception) != NULL)) {
52875
52876 HANDLE_EXCEPTION();
52877 }
52878 }
52879 zend_throw_error(NULL, "Method name must be a string");
52880
52881
52882 HANDLE_EXCEPTION();
52883 } while (0);
52884 }
52885
52886 if (IS_CV == IS_UNUSED) {
52887 obj = Z_OBJ_P(object);
52888 } else {
52889 do {
52890 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
52891 obj = Z_OBJ_P(object);
52892 } else {
52893 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
52894 zend_reference *ref = Z_REF_P(object);
52895
52896 object = &ref->val;
52897 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
52898 obj = Z_OBJ_P(object);
52899 if (IS_CV & IS_VAR) {
52900 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
52901 efree_size(ref, sizeof(zend_reference));
52902 } else {
52903 Z_ADDREF_P(object);
52904 }
52905 }
52906 break;
52907 }
52908 }
52909 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52910 object = ZVAL_UNDEFINED_OP1();
52911 if (UNEXPECTED(EG(exception) != NULL)) {
52912 if (IS_CV != IS_CONST) {
52913
52914 }
52915 HANDLE_EXCEPTION();
52916 }
52917 }
52918 if (IS_CV == IS_CONST) {
52919 function_name = EX_VAR(opline->op2.var);
52920 }
52921 zend_invalid_method_call(object, function_name);
52922
52923
52924 HANDLE_EXCEPTION();
52925 }
52926 } while (0);
52927 }
52928
52929 called_scope = obj->ce;
52930
52931 if (IS_CV == IS_CONST &&
52932 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
52933 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
52934 } else {
52935 zend_object *orig_obj = obj;
52936
52937 if (IS_CV == IS_CONST) {
52938 function_name = EX_VAR(opline->op2.var);
52939 }
52940
52941 /* First, locate the function. */
52942 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
52943 if (UNEXPECTED(fbc == NULL)) {
52944 if (EXPECTED(!EG(exception))) {
52945 zend_undefined_method(obj->ce, Z_STR_P(function_name));
52946 }
52947
52948 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
52949 zend_objects_store_del(orig_obj);
52950 }
52951 HANDLE_EXCEPTION();
52952 }
52953 if (IS_CV == IS_CONST &&
52954 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
52955 EXPECTED(obj == orig_obj)) {
52956 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
52957 }
52958 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
52959 GC_ADDREF(obj); /* For $this pointer */
52960 if (GC_DELREF(orig_obj) == 0) {
52961 zend_objects_store_del(orig_obj);
52962 }
52963 }
52964 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
52965 init_func_run_time_cache(&fbc->op_array);
52966 }
52967 }
52968
52969 if (IS_CV != IS_CONST) {
52970
52971 }
52972
52973 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
52974 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
52975 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
52976 zend_objects_store_del(obj);
52977 if (UNEXPECTED(EG(exception))) {
52978 HANDLE_EXCEPTION();
52979 }
52980 }
52981 /* call static method */
52982 obj = (zend_object*)called_scope;
52983 call_info = ZEND_CALL_NESTED_FUNCTION;
52984 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
52985 if (IS_CV == IS_CV) {
52986 GC_ADDREF(obj); /* For $this pointer */
52987 }
52988 /* CV may be changed indirectly (e.g. when it's a reference) */
52989 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
52990 }
52991
52992 call = zend_vm_stack_push_call_frame(call_info,
52993 fbc, opline->extended_value, obj);
52994 call->prev_execute_data = EX(call);
52995 EX(call) = call;
52996
52997 ZEND_VM_NEXT_OPCODE();
52998 }
52999
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53000 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53001 {
53002 USE_OPLINE
53003 zval *expr_ptr, new_expr;
53004
53005 SAVE_OPLINE();
53006 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
53007 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
53008 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
53009 if (Z_ISREF_P(expr_ptr)) {
53010 Z_ADDREF_P(expr_ptr);
53011 } else {
53012 ZVAL_MAKE_REF_EX(expr_ptr, 2);
53013 }
53014
53015 } else {
53016 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
53017 if (IS_CV == IS_TMP_VAR) {
53018 /* pass */
53019 } else if (IS_CV == IS_CONST) {
53020 Z_TRY_ADDREF_P(expr_ptr);
53021 } else if (IS_CV == IS_CV) {
53022 ZVAL_DEREF(expr_ptr);
53023 Z_TRY_ADDREF_P(expr_ptr);
53024 } else /* if (IS_CV == IS_VAR) */ {
53025 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
53026 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
53027
53028 expr_ptr = Z_REFVAL_P(expr_ptr);
53029 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
53030 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
53031 expr_ptr = &new_expr;
53032 efree_size(ref, sizeof(zend_reference));
53033 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
53034 Z_ADDREF_P(expr_ptr);
53035 }
53036 }
53037 }
53038 }
53039
53040 if (IS_CV != IS_UNUSED) {
53041 zval *offset = EX_VAR(opline->op2.var);
53042 zend_string *str;
53043 zend_ulong hval;
53044
53045 add_again:
53046 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
53047 str = Z_STR_P(offset);
53048 if (IS_CV != IS_CONST) {
53049 if (ZEND_HANDLE_NUMERIC(str, hval)) {
53050 goto num_index;
53051 }
53052 }
53053 str_index:
53054 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
53055 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
53056 hval = Z_LVAL_P(offset);
53057 num_index:
53058 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
53059 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
53060 offset = Z_REFVAL_P(offset);
53061 goto add_again;
53062 } else if (Z_TYPE_P(offset) == IS_NULL) {
53063 str = ZSTR_EMPTY_ALLOC();
53064 goto str_index;
53065 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
53066 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
53067 goto num_index;
53068 } else if (Z_TYPE_P(offset) == IS_FALSE) {
53069 hval = 0;
53070 goto num_index;
53071 } else if (Z_TYPE_P(offset) == IS_TRUE) {
53072 hval = 1;
53073 goto num_index;
53074 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
53075 zend_use_resource_as_offset(offset);
53076 hval = Z_RES_HANDLE_P(offset);
53077 goto num_index;
53078 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
53079 ZVAL_UNDEFINED_OP2();
53080 str = ZSTR_EMPTY_ALLOC();
53081 goto str_index;
53082 } else {
53083 zend_illegal_array_offset_access(offset);
53084 zval_ptr_dtor_nogc(expr_ptr);
53085 }
53086
53087 } else {
53088 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
53089 zend_cannot_add_element();
53090 zval_ptr_dtor_nogc(expr_ptr);
53091 }
53092 }
53093 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
53094 }
53095
ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53096 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53097 {
53098 zval *array;
53099 uint32_t size;
53100 USE_OPLINE
53101
53102 array = EX_VAR(opline->result.var);
53103 if (IS_CV != IS_UNUSED) {
53104 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
53105 ZVAL_ARR(array, zend_new_array(size));
53106 /* Explicitly initialize array as not-packed if flag is set */
53107 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
53108 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
53109 }
53110 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
53111 } else {
53112 ZVAL_ARR(array, zend_new_array(0));
53113 ZEND_VM_NEXT_OPCODE();
53114 }
53115 }
53116
ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53117 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53118 {
53119 USE_OPLINE
53120 zval *container;
53121 zval *offset;
53122 zend_ulong hval;
53123 zend_string *key;
53124
53125 SAVE_OPLINE();
53126 container = EX_VAR(opline->op1.var);
53127 offset = EX_VAR(opline->op2.var);
53128
53129 do {
53130 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
53131 HashTable *ht;
53132
53133 unset_dim_array:
53134 SEPARATE_ARRAY(container);
53135 ht = Z_ARRVAL_P(container);
53136 offset_again:
53137 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
53138 key = Z_STR_P(offset);
53139 if (IS_CV != IS_CONST) {
53140 if (ZEND_HANDLE_NUMERIC(key, hval)) {
53141 goto num_index_dim;
53142 }
53143 }
53144 str_index_dim:
53145 ZEND_ASSERT(ht != &EG(symbol_table));
53146 zend_hash_del(ht, key);
53147 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
53148 hval = Z_LVAL_P(offset);
53149 num_index_dim:
53150 zend_hash_index_del(ht, hval);
53151 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
53152 offset = Z_REFVAL_P(offset);
53153 goto offset_again;
53154 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
53155 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
53156 goto num_index_dim;
53157 } else if (Z_TYPE_P(offset) == IS_NULL) {
53158 key = ZSTR_EMPTY_ALLOC();
53159 goto str_index_dim;
53160 } else if (Z_TYPE_P(offset) == IS_FALSE) {
53161 hval = 0;
53162 goto num_index_dim;
53163 } else if (Z_TYPE_P(offset) == IS_TRUE) {
53164 hval = 1;
53165 goto num_index_dim;
53166 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
53167 zend_use_resource_as_offset(offset);
53168 hval = Z_RES_HANDLE_P(offset);
53169 goto num_index_dim;
53170 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
53171 ZVAL_UNDEFINED_OP2();
53172 key = ZSTR_EMPTY_ALLOC();
53173 goto str_index_dim;
53174 } else {
53175 zend_illegal_array_offset_unset(offset);
53176 }
53177 break;
53178 } else if (Z_ISREF_P(container)) {
53179 container = Z_REFVAL_P(container);
53180 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
53181 goto unset_dim_array;
53182 }
53183 }
53184 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
53185 container = ZVAL_UNDEFINED_OP1();
53186 }
53187 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
53188 offset = ZVAL_UNDEFINED_OP2();
53189 }
53190 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
53191 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
53192 offset++;
53193 }
53194 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
53195 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
53196 zend_throw_error(NULL, "Cannot unset string offsets");
53197 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
53198 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
53199 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
53200 zend_false_to_array_deprecated();
53201 }
53202 } while (0);
53203
53204
53205 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
53206 }
53207
ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53208 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53209 {
53210 USE_OPLINE
53211 zval *container;
53212 zval *offset;
53213 zend_string *name, *tmp_name;
53214
53215 SAVE_OPLINE();
53216 container = EX_VAR(opline->op1.var);
53217 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53218
53219 do {
53220 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
53221 if (Z_ISREF_P(container)) {
53222 container = Z_REFVAL_P(container);
53223 if (Z_TYPE_P(container) != IS_OBJECT) {
53224 if (IS_CV == IS_CV
53225 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
53226 ZVAL_UNDEFINED_OP1();
53227 }
53228 break;
53229 }
53230 } else {
53231 break;
53232 }
53233 }
53234 if (IS_CV == IS_CONST) {
53235 name = Z_STR_P(offset);
53236 } else {
53237 name = zval_try_get_tmp_string(offset, &tmp_name);
53238 if (UNEXPECTED(!name)) {
53239 break;
53240 }
53241 }
53242 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
53243 if (IS_CV != IS_CONST) {
53244 zend_tmp_string_release(tmp_name);
53245 }
53246 } while (0);
53247
53248
53249 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
53250 }
53251
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53252 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53253 {
53254 USE_OPLINE
53255 zval *container;
53256 bool result;
53257 zend_ulong hval;
53258 zval *offset;
53259
53260 SAVE_OPLINE();
53261 container = EX_VAR(opline->op1.var);
53262 offset = EX_VAR(opline->op2.var);
53263
53264 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
53265 HashTable *ht;
53266 zval *value;
53267 zend_string *str;
53268
53269 isset_dim_obj_array:
53270 ht = Z_ARRVAL_P(container);
53271 isset_again:
53272 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
53273 str = Z_STR_P(offset);
53274 if (IS_CV != IS_CONST) {
53275 if (ZEND_HANDLE_NUMERIC(str, hval)) {
53276 goto num_index_prop;
53277 }
53278 }
53279 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
53280 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
53281 hval = Z_LVAL_P(offset);
53282 num_index_prop:
53283 value = zend_hash_index_find(ht, hval);
53284 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
53285 offset = Z_REFVAL_P(offset);
53286 goto isset_again;
53287 } else {
53288 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
53289 if (UNEXPECTED(EG(exception))) {
53290 result = 0;
53291 goto isset_dim_obj_exit;
53292 }
53293 }
53294
53295 if (!(opline->extended_value & ZEND_ISEMPTY)) {
53296 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
53297 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
53298 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
53299
53300 if (IS_CV & (IS_CONST|IS_CV)) {
53301 /* avoid exception check */
53302
53303 ZEND_VM_SMART_BRANCH(result, 0);
53304 }
53305 } else {
53306 result = (value == NULL || !i_zend_is_true(value));
53307 }
53308 goto isset_dim_obj_exit;
53309 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
53310 container = Z_REFVAL_P(container);
53311 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
53312 goto isset_dim_obj_array;
53313 }
53314 }
53315
53316 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
53317 offset++;
53318 }
53319 if (!(opline->extended_value & ZEND_ISEMPTY)) {
53320 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
53321 } else {
53322 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
53323 }
53324
53325 isset_dim_obj_exit:
53326
53327
53328 ZEND_VM_SMART_BRANCH(result, 1);
53329 }
53330
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53331 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53332 {
53333 USE_OPLINE
53334 zval *container;
53335 int result;
53336 zval *offset;
53337 zend_string *name, *tmp_name;
53338
53339 SAVE_OPLINE();
53340 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
53341 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53342
53343 if (IS_CV == IS_CONST ||
53344 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
53345 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
53346 container = Z_REFVAL_P(container);
53347 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
53348 result = (opline->extended_value & ZEND_ISEMPTY);
53349 goto isset_object_finish;
53350 }
53351 } else {
53352 result = (opline->extended_value & ZEND_ISEMPTY);
53353 goto isset_object_finish;
53354 }
53355 }
53356
53357 if (IS_CV == IS_CONST) {
53358 name = Z_STR_P(offset);
53359 } else {
53360 name = zval_try_get_tmp_string(offset, &tmp_name);
53361 if (UNEXPECTED(!name)) {
53362 result = 0;
53363 goto isset_object_finish;
53364 }
53365 }
53366
53367 result =
53368 (opline->extended_value & ZEND_ISEMPTY) ^
53369 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));
53370
53371 if (IS_CV != IS_CONST) {
53372 zend_tmp_string_release(tmp_name);
53373 }
53374
53375 isset_object_finish:
53376
53377
53378 ZEND_VM_SMART_BRANCH(result, 1);
53379 }
53380
ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53381 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53382 {
53383 USE_OPLINE
53384
53385 zval *key, *subject;
53386 HashTable *ht;
53387 bool result;
53388
53389 SAVE_OPLINE();
53390
53391 key = EX_VAR(opline->op1.var);
53392 subject = EX_VAR(opline->op2.var);
53393
53394 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
53395 array_key_exists_array:
53396 ht = Z_ARRVAL_P(subject);
53397 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
53398 } else {
53399 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
53400 subject = Z_REFVAL_P(subject);
53401 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
53402 goto array_key_exists_array;
53403 }
53404 }
53405 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
53406 result = 0;
53407 }
53408
53409
53410 ZEND_VM_SMART_BRANCH(result, 1);
53411 }
53412
53413 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53414 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53415 {
53416 USE_OPLINE
53417
53418 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
53419
53420 SAVE_OPLINE();
53421 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
53422 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
53423 }
53424
53425 /* Destroy the previously yielded value */
53426 zval_ptr_dtor(&generator->value);
53427
53428 /* Destroy the previously yielded key */
53429 zval_ptr_dtor(&generator->key);
53430
53431 /* Set the new yielded value */
53432 if (IS_CV != IS_UNUSED) {
53433 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
53434 /* Constants and temporary variables aren't yieldable by reference,
53435 * but we still allow them with a notice. */
53436 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
53437 zval *value;
53438
53439 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
53440
53441 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
53442 ZVAL_COPY_VALUE(&generator->value, value);
53443 if (IS_CV == IS_CONST) {
53444 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
53445 Z_ADDREF(generator->value);
53446 }
53447 }
53448 } else {
53449 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
53450
53451 /* If a function call result is yielded and the function did
53452 * not return by reference we throw a notice. */
53453 do {
53454 if (IS_CV == IS_VAR) {
53455 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
53456 if (opline->extended_value == ZEND_RETURNS_FUNCTION
53457 && !Z_ISREF_P(value_ptr)) {
53458 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
53459 ZVAL_COPY(&generator->value, value_ptr);
53460 break;
53461 }
53462 }
53463 if (Z_ISREF_P(value_ptr)) {
53464 Z_ADDREF_P(value_ptr);
53465 } else {
53466 ZVAL_MAKE_REF_EX(value_ptr, 2);
53467 }
53468 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
53469 } while (0);
53470
53471 }
53472 } else {
53473 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
53474
53475 /* Consts, temporary variables and references need copying */
53476 if (IS_CV == IS_CONST) {
53477 ZVAL_COPY_VALUE(&generator->value, value);
53478 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
53479 Z_ADDREF(generator->value);
53480 }
53481 } else if (IS_CV == IS_TMP_VAR) {
53482 ZVAL_COPY_VALUE(&generator->value, value);
53483 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
53484 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
53485
53486 } else {
53487 ZVAL_COPY_VALUE(&generator->value, value);
53488 if (IS_CV == IS_CV) {
53489 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
53490 }
53491 }
53492 }
53493 } else {
53494 /* If no value was specified yield null */
53495 ZVAL_NULL(&generator->value);
53496 }
53497
53498 /* Set the new yielded key */
53499 if (IS_CV != IS_UNUSED) {
53500 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53501 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
53502 key = Z_REFVAL_P(key);
53503 }
53504 ZVAL_COPY(&generator->key, key);
53505
53506 if (Z_TYPE(generator->key) == IS_LONG
53507 && Z_LVAL(generator->key) > generator->largest_used_integer_key
53508 ) {
53509 generator->largest_used_integer_key = Z_LVAL(generator->key);
53510 }
53511 } else {
53512 /* If no key was specified we use auto-increment keys */
53513 generator->largest_used_integer_key++;
53514 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
53515 }
53516
53517 if (RETURN_VALUE_USED(opline)) {
53518 /* If the return value of yield is used set the send
53519 * target and initialize it to NULL */
53520 generator->send_target = EX_VAR(opline->result.var);
53521 ZVAL_NULL(generator->send_target);
53522 } else {
53523 generator->send_target = NULL;
53524 }
53525
53526 /* We increment to the next op, so we are at the correct position when the
53527 * generator is resumed. */
53528 ZEND_VM_INC_OPCODE();
53529
53530 /* The GOTO VM uses a local opline variable. We need to set the opline
53531 * variable in execute_data so we don't resume at an old position. */
53532 SAVE_OPLINE();
53533
53534 ZEND_VM_RETURN();
53535 }
53536
ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53537 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53538 {
53539 /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
53540 /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
53541 /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
53542 USE_OPLINE
53543 zval *op1, *op2;
53544 bool result;
53545
53546 op1 = EX_VAR(opline->op1.var);
53547 op2 = EX_VAR(opline->op2.var);
53548 result = fast_is_identical_function(op1, op2);
53549 /* Free is a no-op for const/cv */
53550 ZEND_VM_SMART_BRANCH(result, 0);
53551 }
53552
ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53553 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53554 {
53555 USE_OPLINE
53556 zval *op1, *op2;
53557 bool result;
53558
53559 op1 = EX_VAR(opline->op1.var);
53560 op2 = EX_VAR(opline->op2.var);
53561 result = fast_is_identical_function(op1, op2);
53562 /* Free is a no-op for const/cv */
53563 ZEND_VM_SMART_BRANCH(!result, 0);
53564 }
53565
ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53566 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53567 {
53568 USE_OPLINE
53569
53570 SAVE_OPLINE();
53571 zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);
53572 ZEND_VM_NEXT_OPCODE(); /* Never reached */
53573 }
53574
53575
53576 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
53577 # undef ZEND_VM_TAIL_CALL
53578 # undef ZEND_VM_CONTINUE
53579 # undef ZEND_VM_RETURN
53580
53581 # define ZEND_VM_TAIL_CALL(call) call; ZEND_VM_CONTINUE()
53582 # define ZEND_VM_CONTINUE() HYBRID_NEXT()
53583 # define ZEND_VM_RETURN() goto HYBRID_HALT_LABEL
53584 #endif
53585
53586
53587 #if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
53588 # pragma GCC push_options
53589 # pragma GCC optimize("no-gcse")
53590 # pragma GCC optimize("no-ivopts")
53591 #endif
execute_ex(zend_execute_data * ex)53592 ZEND_API void execute_ex(zend_execute_data *ex)
53593 {
53594 DCL_OPLINE
53595
53596 #if defined(ZEND_VM_IP_GLOBAL_REG) || defined(ZEND_VM_FP_GLOBAL_REG)
53597 struct {
53598 #ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
53599 char hybrid_jit_red_zone[ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE];
53600 #endif
53601 #ifdef ZEND_VM_IP_GLOBAL_REG
53602 const zend_op *orig_opline;
53603 #endif
53604 #ifdef ZEND_VM_FP_GLOBAL_REG
53605 zend_execute_data *orig_execute_data;
53606 #endif
53607 } vm_stack_data;
53608 #endif
53609 #ifdef ZEND_VM_IP_GLOBAL_REG
53610 vm_stack_data.orig_opline = opline;
53611 #endif
53612 #ifdef ZEND_VM_FP_GLOBAL_REG
53613 vm_stack_data.orig_execute_data = execute_data;
53614 execute_data = ex;
53615 #else
53616 zend_execute_data *execute_data = ex;
53617 #endif
53618
53619 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
53620 if (UNEXPECTED(execute_data == NULL)) {
53621 static const void * const labels[] = {
53622 (void*)&&ZEND_NOP_SPEC_LABEL,
53623 (void*)&&ZEND_ADD_SPEC_CONST_CONST_LABEL,
53624 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
53625 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
53626 (void*)&&ZEND_NULL_LABEL,
53627 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
53628 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
53629 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53630 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53631 (void*)&&ZEND_NULL_LABEL,
53632 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53633 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
53634 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53635 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53636 (void*)&&ZEND_NULL_LABEL,
53637 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53638 (void*)&&ZEND_NULL_LABEL,
53639 (void*)&&ZEND_NULL_LABEL,
53640 (void*)&&ZEND_NULL_LABEL,
53641 (void*)&&ZEND_NULL_LABEL,
53642 (void*)&&ZEND_NULL_LABEL,
53643 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
53644 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53645 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53646 (void*)&&ZEND_NULL_LABEL,
53647 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53648 (void*)&&ZEND_SUB_SPEC_CONST_CONST_LABEL,
53649 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
53650 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
53651 (void*)&&ZEND_NULL_LABEL,
53652 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
53653 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
53654 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53655 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53656 (void*)&&ZEND_NULL_LABEL,
53657 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53658 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
53659 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53660 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53661 (void*)&&ZEND_NULL_LABEL,
53662 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53663 (void*)&&ZEND_NULL_LABEL,
53664 (void*)&&ZEND_NULL_LABEL,
53665 (void*)&&ZEND_NULL_LABEL,
53666 (void*)&&ZEND_NULL_LABEL,
53667 (void*)&&ZEND_NULL_LABEL,
53668 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
53669 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53670 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53671 (void*)&&ZEND_NULL_LABEL,
53672 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53673 (void*)&&ZEND_MUL_SPEC_CONST_CONST_LABEL,
53674 (void*)&&ZEND_NULL_LABEL,
53675 (void*)&&ZEND_NULL_LABEL,
53676 (void*)&&ZEND_NULL_LABEL,
53677 (void*)&&ZEND_NULL_LABEL,
53678 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
53679 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53680 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53681 (void*)&&ZEND_NULL_LABEL,
53682 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53683 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
53684 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53685 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53686 (void*)&&ZEND_NULL_LABEL,
53687 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53688 (void*)&&ZEND_NULL_LABEL,
53689 (void*)&&ZEND_NULL_LABEL,
53690 (void*)&&ZEND_NULL_LABEL,
53691 (void*)&&ZEND_NULL_LABEL,
53692 (void*)&&ZEND_NULL_LABEL,
53693 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
53694 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53695 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53696 (void*)&&ZEND_NULL_LABEL,
53697 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53698 (void*)&&ZEND_DIV_SPEC_CONST_CONST_LABEL,
53699 (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
53700 (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
53701 (void*)&&ZEND_NULL_LABEL,
53702 (void*)&&ZEND_DIV_SPEC_CONST_CV_LABEL,
53703 (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
53704 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
53705 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
53706 (void*)&&ZEND_NULL_LABEL,
53707 (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
53708 (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
53709 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
53710 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
53711 (void*)&&ZEND_NULL_LABEL,
53712 (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
53713 (void*)&&ZEND_NULL_LABEL,
53714 (void*)&&ZEND_NULL_LABEL,
53715 (void*)&&ZEND_NULL_LABEL,
53716 (void*)&&ZEND_NULL_LABEL,
53717 (void*)&&ZEND_NULL_LABEL,
53718 (void*)&&ZEND_DIV_SPEC_CV_CONST_LABEL,
53719 (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
53720 (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
53721 (void*)&&ZEND_NULL_LABEL,
53722 (void*)&&ZEND_DIV_SPEC_CV_CV_LABEL,
53723 (void*)&&ZEND_MOD_SPEC_CONST_CONST_LABEL,
53724 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
53725 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
53726 (void*)&&ZEND_NULL_LABEL,
53727 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
53728 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
53729 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53730 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53731 (void*)&&ZEND_NULL_LABEL,
53732 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53733 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
53734 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53735 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53736 (void*)&&ZEND_NULL_LABEL,
53737 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53738 (void*)&&ZEND_NULL_LABEL,
53739 (void*)&&ZEND_NULL_LABEL,
53740 (void*)&&ZEND_NULL_LABEL,
53741 (void*)&&ZEND_NULL_LABEL,
53742 (void*)&&ZEND_NULL_LABEL,
53743 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
53744 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53745 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53746 (void*)&&ZEND_NULL_LABEL,
53747 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53748 (void*)&&ZEND_SL_SPEC_CONST_CONST_LABEL,
53749 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
53750 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
53751 (void*)&&ZEND_NULL_LABEL,
53752 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
53753 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
53754 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53755 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53756 (void*)&&ZEND_NULL_LABEL,
53757 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53758 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
53759 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53760 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53761 (void*)&&ZEND_NULL_LABEL,
53762 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53763 (void*)&&ZEND_NULL_LABEL,
53764 (void*)&&ZEND_NULL_LABEL,
53765 (void*)&&ZEND_NULL_LABEL,
53766 (void*)&&ZEND_NULL_LABEL,
53767 (void*)&&ZEND_NULL_LABEL,
53768 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
53769 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53770 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53771 (void*)&&ZEND_NULL_LABEL,
53772 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53773 (void*)&&ZEND_SR_SPEC_CONST_CONST_LABEL,
53774 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
53775 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
53776 (void*)&&ZEND_NULL_LABEL,
53777 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
53778 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
53779 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53780 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53781 (void*)&&ZEND_NULL_LABEL,
53782 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53783 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
53784 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53785 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53786 (void*)&&ZEND_NULL_LABEL,
53787 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53788 (void*)&&ZEND_NULL_LABEL,
53789 (void*)&&ZEND_NULL_LABEL,
53790 (void*)&&ZEND_NULL_LABEL,
53791 (void*)&&ZEND_NULL_LABEL,
53792 (void*)&&ZEND_NULL_LABEL,
53793 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
53794 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53795 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53796 (void*)&&ZEND_NULL_LABEL,
53797 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53798 (void*)&&ZEND_NULL_LABEL,
53799 (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
53800 (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
53801 (void*)&&ZEND_NULL_LABEL,
53802 (void*)&&ZEND_CONCAT_SPEC_CONST_CV_LABEL,
53803 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
53804 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
53805 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
53806 (void*)&&ZEND_NULL_LABEL,
53807 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
53808 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
53809 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
53810 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
53811 (void*)&&ZEND_NULL_LABEL,
53812 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
53813 (void*)&&ZEND_NULL_LABEL,
53814 (void*)&&ZEND_NULL_LABEL,
53815 (void*)&&ZEND_NULL_LABEL,
53816 (void*)&&ZEND_NULL_LABEL,
53817 (void*)&&ZEND_NULL_LABEL,
53818 (void*)&&ZEND_CONCAT_SPEC_CV_CONST_LABEL,
53819 (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
53820 (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
53821 (void*)&&ZEND_NULL_LABEL,
53822 (void*)&&ZEND_CONCAT_SPEC_CV_CV_LABEL,
53823 (void*)&&ZEND_BW_OR_SPEC_CONST_CONST_LABEL,
53824 (void*)&&ZEND_NULL_LABEL,
53825 (void*)&&ZEND_NULL_LABEL,
53826 (void*)&&ZEND_NULL_LABEL,
53827 (void*)&&ZEND_NULL_LABEL,
53828 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
53829 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53830 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53831 (void*)&&ZEND_NULL_LABEL,
53832 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53833 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
53834 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53835 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53836 (void*)&&ZEND_NULL_LABEL,
53837 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53838 (void*)&&ZEND_NULL_LABEL,
53839 (void*)&&ZEND_NULL_LABEL,
53840 (void*)&&ZEND_NULL_LABEL,
53841 (void*)&&ZEND_NULL_LABEL,
53842 (void*)&&ZEND_NULL_LABEL,
53843 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
53844 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53845 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53846 (void*)&&ZEND_NULL_LABEL,
53847 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53848 (void*)&&ZEND_BW_AND_SPEC_CONST_CONST_LABEL,
53849 (void*)&&ZEND_NULL_LABEL,
53850 (void*)&&ZEND_NULL_LABEL,
53851 (void*)&&ZEND_NULL_LABEL,
53852 (void*)&&ZEND_NULL_LABEL,
53853 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
53854 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53855 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53856 (void*)&&ZEND_NULL_LABEL,
53857 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53858 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
53859 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53860 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53861 (void*)&&ZEND_NULL_LABEL,
53862 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53863 (void*)&&ZEND_NULL_LABEL,
53864 (void*)&&ZEND_NULL_LABEL,
53865 (void*)&&ZEND_NULL_LABEL,
53866 (void*)&&ZEND_NULL_LABEL,
53867 (void*)&&ZEND_NULL_LABEL,
53868 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
53869 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53870 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53871 (void*)&&ZEND_NULL_LABEL,
53872 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53873 (void*)&&ZEND_BW_XOR_SPEC_CONST_CONST_LABEL,
53874 (void*)&&ZEND_NULL_LABEL,
53875 (void*)&&ZEND_NULL_LABEL,
53876 (void*)&&ZEND_NULL_LABEL,
53877 (void*)&&ZEND_NULL_LABEL,
53878 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
53879 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53880 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53881 (void*)&&ZEND_NULL_LABEL,
53882 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53883 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
53884 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53885 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53886 (void*)&&ZEND_NULL_LABEL,
53887 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53888 (void*)&&ZEND_NULL_LABEL,
53889 (void*)&&ZEND_NULL_LABEL,
53890 (void*)&&ZEND_NULL_LABEL,
53891 (void*)&&ZEND_NULL_LABEL,
53892 (void*)&&ZEND_NULL_LABEL,
53893 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
53894 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53895 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53896 (void*)&&ZEND_NULL_LABEL,
53897 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53898 (void*)&&ZEND_POW_SPEC_CONST_CONST_LABEL,
53899 (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
53900 (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
53901 (void*)&&ZEND_NULL_LABEL,
53902 (void*)&&ZEND_POW_SPEC_CONST_CV_LABEL,
53903 (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
53904 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
53905 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
53906 (void*)&&ZEND_NULL_LABEL,
53907 (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
53908 (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
53909 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
53910 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
53911 (void*)&&ZEND_NULL_LABEL,
53912 (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
53913 (void*)&&ZEND_NULL_LABEL,
53914 (void*)&&ZEND_NULL_LABEL,
53915 (void*)&&ZEND_NULL_LABEL,
53916 (void*)&&ZEND_NULL_LABEL,
53917 (void*)&&ZEND_NULL_LABEL,
53918 (void*)&&ZEND_POW_SPEC_CV_CONST_LABEL,
53919 (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
53920 (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
53921 (void*)&&ZEND_NULL_LABEL,
53922 (void*)&&ZEND_POW_SPEC_CV_CV_LABEL,
53923 (void*)&&ZEND_BW_NOT_SPEC_CONST_LABEL,
53924 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
53925 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
53926 (void*)&&ZEND_NULL_LABEL,
53927 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
53928 (void*)&&ZEND_BOOL_NOT_SPEC_CONST_LABEL,
53929 (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
53930 (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
53931 (void*)&&ZEND_NULL_LABEL,
53932 (void*)&&ZEND_BOOL_NOT_SPEC_CV_LABEL,
53933 (void*)&&ZEND_BOOL_XOR_SPEC_CONST_CONST_LABEL,
53934 (void*)&&ZEND_NULL_LABEL,
53935 (void*)&&ZEND_NULL_LABEL,
53936 (void*)&&ZEND_NULL_LABEL,
53937 (void*)&&ZEND_NULL_LABEL,
53938 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
53939 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
53940 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
53941 (void*)&&ZEND_NULL_LABEL,
53942 (void*)&&ZEND_NULL_LABEL,
53943 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
53944 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
53945 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
53946 (void*)&&ZEND_NULL_LABEL,
53947 (void*)&&ZEND_NULL_LABEL,
53948 (void*)&&ZEND_NULL_LABEL,
53949 (void*)&&ZEND_NULL_LABEL,
53950 (void*)&&ZEND_NULL_LABEL,
53951 (void*)&&ZEND_NULL_LABEL,
53952 (void*)&&ZEND_NULL_LABEL,
53953 (void*)&&ZEND_BOOL_XOR_SPEC_CV_CONST_LABEL,
53954 (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
53955 (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
53956 (void*)&&ZEND_NULL_LABEL,
53957 (void*)&&ZEND_BOOL_XOR_SPEC_CV_CV_LABEL,
53958 (void*)&&ZEND_IS_IDENTICAL_SPEC_CONST_CONST_LABEL,
53959 (void*)&&ZEND_NULL_LABEL,
53960 (void*)&&ZEND_NULL_LABEL,
53961 (void*)&&ZEND_NULL_LABEL,
53962 (void*)&&ZEND_NULL_LABEL,
53963 (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_CONST_LABEL,
53964 (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_TMP_LABEL,
53965 (void*)&&ZEND_NULL_LABEL,
53966 (void*)&&ZEND_NULL_LABEL,
53967 (void*)&&ZEND_NULL_LABEL,
53968 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_CONST_LABEL,
53969 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_TMP_LABEL,
53970 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_VAR_LABEL,
53971 (void*)&&ZEND_NULL_LABEL,
53972 (void*)&&ZEND_NULL_LABEL,
53973 (void*)&&ZEND_NULL_LABEL,
53974 (void*)&&ZEND_NULL_LABEL,
53975 (void*)&&ZEND_NULL_LABEL,
53976 (void*)&&ZEND_NULL_LABEL,
53977 (void*)&&ZEND_NULL_LABEL,
53978 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CONST_LABEL,
53979 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_TMP_LABEL,
53980 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_VAR_LABEL,
53981 (void*)&&ZEND_NULL_LABEL,
53982 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CV_LABEL,
53983 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_LABEL,
53984 (void*)&&ZEND_NULL_LABEL,
53985 (void*)&&ZEND_NULL_LABEL,
53986 (void*)&&ZEND_NULL_LABEL,
53987 (void*)&&ZEND_NULL_LABEL,
53988 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_LABEL,
53989 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_LABEL,
53990 (void*)&&ZEND_NULL_LABEL,
53991 (void*)&&ZEND_NULL_LABEL,
53992 (void*)&&ZEND_NULL_LABEL,
53993 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_LABEL,
53994 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_LABEL,
53995 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_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_IS_NOT_IDENTICAL_SPEC_CV_CONST_LABEL,
54004 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_LABEL,
54005 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_LABEL,
54006 (void*)&&ZEND_NULL_LABEL,
54007 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_LABEL,
54008 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
54009 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
54010 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
54011 (void*)&&ZEND_NULL_LABEL,
54012 (void*)&&ZEND_NULL_LABEL,
54013 (void*)&&ZEND_NULL_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_NULL_LABEL,
54021 (void*)&&ZEND_NULL_LABEL,
54022 (void*)&&ZEND_NULL_LABEL,
54023 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL,
54024 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
54025 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_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_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54030 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54031 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL,
54039 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
54040 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
54041 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54042 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54043 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54044 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54045 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54046 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54047 (void*)&&ZEND_NULL_LABEL,
54048 (void*)&&ZEND_NULL_LABEL,
54049 (void*)&&ZEND_NULL_LABEL,
54050 (void*)&&ZEND_NULL_LABEL,
54051 (void*)&&ZEND_NULL_LABEL,
54052 (void*)&&ZEND_NULL_LABEL,
54053 (void*)&&ZEND_NULL_LABEL,
54054 (void*)&&ZEND_NULL_LABEL,
54055 (void*)&&ZEND_NULL_LABEL,
54056 (void*)&&ZEND_NULL_LABEL,
54057 (void*)&&ZEND_NULL_LABEL,
54058 (void*)&&ZEND_NULL_LABEL,
54059 (void*)&&ZEND_NULL_LABEL,
54060 (void*)&&ZEND_NULL_LABEL,
54061 (void*)&&ZEND_NULL_LABEL,
54062 (void*)&&ZEND_NULL_LABEL,
54063 (void*)&&ZEND_NULL_LABEL,
54064 (void*)&&ZEND_NULL_LABEL,
54065 (void*)&&ZEND_NULL_LABEL,
54066 (void*)&&ZEND_NULL_LABEL,
54067 (void*)&&ZEND_NULL_LABEL,
54068 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_LABEL,
54069 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
54070 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
54071 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
54072 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
54073 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
54074 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
54075 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
54076 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
54077 (void*)&&ZEND_NULL_LABEL,
54078 (void*)&&ZEND_NULL_LABEL,
54079 (void*)&&ZEND_NULL_LABEL,
54080 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_LABEL,
54081 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
54082 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
54083 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
54084 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
54085 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
54086 (void*)&&ZEND_NULL_LABEL,
54087 (void*)&&ZEND_NULL_LABEL,
54088 (void*)&&ZEND_NULL_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_NULL_LABEL,
54096 (void*)&&ZEND_NULL_LABEL,
54097 (void*)&&ZEND_NULL_LABEL,
54098 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
54099 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
54100 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_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_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54105 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54106 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
54114 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
54115 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
54116 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54117 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54118 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54119 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54120 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54121 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54122 (void*)&&ZEND_NULL_LABEL,
54123 (void*)&&ZEND_NULL_LABEL,
54124 (void*)&&ZEND_NULL_LABEL,
54125 (void*)&&ZEND_NULL_LABEL,
54126 (void*)&&ZEND_NULL_LABEL,
54127 (void*)&&ZEND_NULL_LABEL,
54128 (void*)&&ZEND_NULL_LABEL,
54129 (void*)&&ZEND_NULL_LABEL,
54130 (void*)&&ZEND_NULL_LABEL,
54131 (void*)&&ZEND_NULL_LABEL,
54132 (void*)&&ZEND_NULL_LABEL,
54133 (void*)&&ZEND_NULL_LABEL,
54134 (void*)&&ZEND_NULL_LABEL,
54135 (void*)&&ZEND_NULL_LABEL,
54136 (void*)&&ZEND_NULL_LABEL,
54137 (void*)&&ZEND_NULL_LABEL,
54138 (void*)&&ZEND_NULL_LABEL,
54139 (void*)&&ZEND_NULL_LABEL,
54140 (void*)&&ZEND_NULL_LABEL,
54141 (void*)&&ZEND_NULL_LABEL,
54142 (void*)&&ZEND_NULL_LABEL,
54143 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_LABEL,
54144 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
54145 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
54146 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
54147 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
54148 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
54149 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
54150 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
54151 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
54152 (void*)&&ZEND_NULL_LABEL,
54153 (void*)&&ZEND_NULL_LABEL,
54154 (void*)&&ZEND_NULL_LABEL,
54155 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_LABEL,
54156 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
54157 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
54158 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
54159 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
54160 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
54161 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
54162 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54163 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54164 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
54165 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54166 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54167 (void*)&&ZEND_NULL_LABEL,
54168 (void*)&&ZEND_NULL_LABEL,
54169 (void*)&&ZEND_NULL_LABEL,
54170 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
54171 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54172 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54173 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
54174 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54175 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_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_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54180 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54181 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54182 (void*)&&ZEND_NULL_LABEL,
54183 (void*)&&ZEND_NULL_LABEL,
54184 (void*)&&ZEND_NULL_LABEL,
54185 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54186 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54187 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54188 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
54189 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54190 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
54191 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54192 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54193 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54194 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54195 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54196 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54197 (void*)&&ZEND_NULL_LABEL,
54198 (void*)&&ZEND_NULL_LABEL,
54199 (void*)&&ZEND_NULL_LABEL,
54200 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54201 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54202 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54203 (void*)&&ZEND_NULL_LABEL,
54204 (void*)&&ZEND_NULL_LABEL,
54205 (void*)&&ZEND_NULL_LABEL,
54206 (void*)&&ZEND_NULL_LABEL,
54207 (void*)&&ZEND_NULL_LABEL,
54208 (void*)&&ZEND_NULL_LABEL,
54209 (void*)&&ZEND_NULL_LABEL,
54210 (void*)&&ZEND_NULL_LABEL,
54211 (void*)&&ZEND_NULL_LABEL,
54212 (void*)&&ZEND_NULL_LABEL,
54213 (void*)&&ZEND_NULL_LABEL,
54214 (void*)&&ZEND_NULL_LABEL,
54215 (void*)&&ZEND_NULL_LABEL,
54216 (void*)&&ZEND_NULL_LABEL,
54217 (void*)&&ZEND_NULL_LABEL,
54218 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
54219 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54220 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
54221 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54222 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54223 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54224 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54225 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54226 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54227 (void*)&&ZEND_NULL_LABEL,
54228 (void*)&&ZEND_NULL_LABEL,
54229 (void*)&&ZEND_NULL_LABEL,
54230 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54231 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54232 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54233 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
54234 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
54235 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
54236 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
54237 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54238 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54239 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
54240 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54241 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54242 (void*)&&ZEND_NULL_LABEL,
54243 (void*)&&ZEND_NULL_LABEL,
54244 (void*)&&ZEND_NULL_LABEL,
54245 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
54246 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54247 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54248 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
54249 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54250 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_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_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54255 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54256 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54257 (void*)&&ZEND_NULL_LABEL,
54258 (void*)&&ZEND_NULL_LABEL,
54259 (void*)&&ZEND_NULL_LABEL,
54260 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54261 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54262 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54263 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
54264 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54265 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
54266 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54267 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54268 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54269 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54270 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54271 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_TMPVARCV_LABEL,
54276 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54277 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54278 (void*)&&ZEND_NULL_LABEL,
54279 (void*)&&ZEND_NULL_LABEL,
54280 (void*)&&ZEND_NULL_LABEL,
54281 (void*)&&ZEND_NULL_LABEL,
54282 (void*)&&ZEND_NULL_LABEL,
54283 (void*)&&ZEND_NULL_LABEL,
54284 (void*)&&ZEND_NULL_LABEL,
54285 (void*)&&ZEND_NULL_LABEL,
54286 (void*)&&ZEND_NULL_LABEL,
54287 (void*)&&ZEND_NULL_LABEL,
54288 (void*)&&ZEND_NULL_LABEL,
54289 (void*)&&ZEND_NULL_LABEL,
54290 (void*)&&ZEND_NULL_LABEL,
54291 (void*)&&ZEND_NULL_LABEL,
54292 (void*)&&ZEND_NULL_LABEL,
54293 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
54294 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54295 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
54296 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54297 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54298 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54299 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54300 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54301 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54302 (void*)&&ZEND_NULL_LABEL,
54303 (void*)&&ZEND_NULL_LABEL,
54304 (void*)&&ZEND_NULL_LABEL,
54305 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54306 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54307 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54308 (void*)&&ZEND_NULL_LABEL,
54309 (void*)&&ZEND_NULL_LABEL,
54310 (void*)&&ZEND_NULL_LABEL,
54311 (void*)&&ZEND_NULL_LABEL,
54312 (void*)&&ZEND_NULL_LABEL,
54313 (void*)&&ZEND_NULL_LABEL,
54314 (void*)&&ZEND_NULL_LABEL,
54315 (void*)&&ZEND_NULL_LABEL,
54316 (void*)&&ZEND_NULL_LABEL,
54317 (void*)&&ZEND_NULL_LABEL,
54318 (void*)&&ZEND_NULL_LABEL,
54319 (void*)&&ZEND_NULL_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_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_LABEL,
54329 (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_LABEL,
54330 (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_LABEL,
54331 (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_LABEL,
54332 (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_LABEL,
54333 (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_LABEL,
54334 (void*)&&ZEND_NULL_LABEL,
54335 (void*)&&ZEND_NULL_LABEL,
54336 (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
54337 (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_LABEL,
54338 (void*)&&ZEND_NULL_LABEL,
54339 (void*)&&ZEND_NULL_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_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_LABEL,
54349 (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_LABEL,
54350 (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_LABEL,
54351 (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_LABEL,
54352 (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_LABEL,
54353 (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_LABEL,
54354 (void*)&&ZEND_NULL_LABEL,
54355 (void*)&&ZEND_NULL_LABEL,
54356 (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_LABEL,
54357 (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_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_NULL_LABEL,
54391 (void*)&&ZEND_NULL_LABEL,
54392 (void*)&&ZEND_NULL_LABEL,
54393 (void*)&&ZEND_NULL_LABEL,
54394 (void*)&&ZEND_NULL_LABEL,
54395 (void*)&&ZEND_NULL_LABEL,
54396 (void*)&&ZEND_NULL_LABEL,
54397 (void*)&&ZEND_NULL_LABEL,
54398 (void*)&&ZEND_NULL_LABEL,
54399 (void*)&&ZEND_NULL_LABEL,
54400 (void*)&&ZEND_NULL_LABEL,
54401 (void*)&&ZEND_NULL_LABEL,
54402 (void*)&&ZEND_NULL_LABEL,
54403 (void*)&&ZEND_NULL_LABEL,
54404 (void*)&&ZEND_NULL_LABEL,
54405 (void*)&&ZEND_NULL_LABEL,
54406 (void*)&&ZEND_NULL_LABEL,
54407 (void*)&&ZEND_NULL_LABEL,
54408 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
54409 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
54410 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
54411 (void*)&&ZEND_NULL_LABEL,
54412 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
54413 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
54414 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
54415 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54416 (void*)&&ZEND_NULL_LABEL,
54417 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54418 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
54419 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
54420 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54421 (void*)&&ZEND_NULL_LABEL,
54422 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54423 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_LABEL,
54424 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_LABEL,
54425 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_LABEL,
54426 (void*)&&ZEND_NULL_LABEL,
54427 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_LABEL,
54428 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
54429 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
54430 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
54431 (void*)&&ZEND_NULL_LABEL,
54432 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_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_NULL_LABEL,
54441 (void*)&&ZEND_NULL_LABEL,
54442 (void*)&&ZEND_NULL_LABEL,
54443 (void*)&&ZEND_NULL_LABEL,
54444 (void*)&&ZEND_NULL_LABEL,
54445 (void*)&&ZEND_NULL_LABEL,
54446 (void*)&&ZEND_NULL_LABEL,
54447 (void*)&&ZEND_NULL_LABEL,
54448 (void*)&&ZEND_NULL_LABEL,
54449 (void*)&&ZEND_NULL_LABEL,
54450 (void*)&&ZEND_NULL_LABEL,
54451 (void*)&&ZEND_NULL_LABEL,
54452 (void*)&&ZEND_NULL_LABEL,
54453 (void*)&&ZEND_NULL_LABEL,
54454 (void*)&&ZEND_NULL_LABEL,
54455 (void*)&&ZEND_NULL_LABEL,
54456 (void*)&&ZEND_NULL_LABEL,
54457 (void*)&&ZEND_NULL_LABEL,
54458 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
54459 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
54460 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
54461 (void*)&&ZEND_NULL_LABEL,
54462 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_LABEL,
54463 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
54464 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
54465 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54466 (void*)&&ZEND_NULL_LABEL,
54467 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54468 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
54469 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
54470 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54471 (void*)&&ZEND_NULL_LABEL,
54472 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54473 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_LABEL,
54474 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_LABEL,
54475 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_LABEL,
54476 (void*)&&ZEND_NULL_LABEL,
54477 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_LABEL,
54478 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_LABEL,
54479 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_LABEL,
54480 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_LABEL,
54481 (void*)&&ZEND_NULL_LABEL,
54482 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_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_NULL_LABEL,
54516 (void*)&&ZEND_NULL_LABEL,
54517 (void*)&&ZEND_NULL_LABEL,
54518 (void*)&&ZEND_NULL_LABEL,
54519 (void*)&&ZEND_NULL_LABEL,
54520 (void*)&&ZEND_NULL_LABEL,
54521 (void*)&&ZEND_NULL_LABEL,
54522 (void*)&&ZEND_NULL_LABEL,
54523 (void*)&&ZEND_NULL_LABEL,
54524 (void*)&&ZEND_NULL_LABEL,
54525 (void*)&&ZEND_NULL_LABEL,
54526 (void*)&&ZEND_NULL_LABEL,
54527 (void*)&&ZEND_NULL_LABEL,
54528 (void*)&&ZEND_NULL_LABEL,
54529 (void*)&&ZEND_NULL_LABEL,
54530 (void*)&&ZEND_NULL_LABEL,
54531 (void*)&&ZEND_NULL_LABEL,
54532 (void*)&&ZEND_NULL_LABEL,
54533 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
54534 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
54535 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
54536 (void*)&&ZEND_NULL_LABEL,
54537 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
54538 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
54539 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
54540 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54541 (void*)&&ZEND_NULL_LABEL,
54542 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54543 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
54544 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
54545 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54546 (void*)&&ZEND_NULL_LABEL,
54547 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54548 (void*)&&ZEND_NULL_LABEL,
54549 (void*)&&ZEND_NULL_LABEL,
54550 (void*)&&ZEND_NULL_LABEL,
54551 (void*)&&ZEND_NULL_LABEL,
54552 (void*)&&ZEND_NULL_LABEL,
54553 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
54554 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
54555 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
54556 (void*)&&ZEND_NULL_LABEL,
54557 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_LABEL,
54558 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_LABEL,
54559 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_LABEL,
54560 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
54561 (void*)&&ZEND_NULL_LABEL,
54562 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
54563 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
54564 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
54565 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
54566 (void*)&&ZEND_NULL_LABEL,
54567 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
54568 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
54569 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
54570 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
54571 (void*)&&ZEND_NULL_LABEL,
54572 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
54573 (void*)&&ZEND_NULL_LABEL,
54574 (void*)&&ZEND_NULL_LABEL,
54575 (void*)&&ZEND_NULL_LABEL,
54576 (void*)&&ZEND_NULL_LABEL,
54577 (void*)&&ZEND_NULL_LABEL,
54578 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_LABEL,
54579 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_LABEL,
54580 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
54581 (void*)&&ZEND_NULL_LABEL,
54582 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
54583 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
54584 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
54585 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
54586 (void*)&&ZEND_NULL_LABEL,
54587 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_LABEL,
54588 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
54589 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
54590 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54591 (void*)&&ZEND_NULL_LABEL,
54592 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54593 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
54594 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
54595 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54596 (void*)&&ZEND_NULL_LABEL,
54597 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_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_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_LABEL,
54604 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_LABEL,
54605 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_LABEL,
54606 (void*)&&ZEND_NULL_LABEL,
54607 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_LABEL,
54608 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_LABEL,
54609 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_LABEL,
54610 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_LABEL,
54611 (void*)&&ZEND_NULL_LABEL,
54612 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_LABEL,
54613 (void*)&&ZEND_NULL_LABEL,
54614 (void*)&&ZEND_NULL_LABEL,
54615 (void*)&&ZEND_NULL_LABEL,
54616 (void*)&&ZEND_NULL_LABEL,
54617 (void*)&&ZEND_NULL_LABEL,
54618 (void*)&&ZEND_NULL_LABEL,
54619 (void*)&&ZEND_NULL_LABEL,
54620 (void*)&&ZEND_NULL_LABEL,
54621 (void*)&&ZEND_NULL_LABEL,
54622 (void*)&&ZEND_NULL_LABEL,
54623 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CONST_LABEL,
54624 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
54625 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
54626 (void*)&&ZEND_NULL_LABEL,
54627 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CV_LABEL,
54628 (void*)&&ZEND_NULL_LABEL,
54629 (void*)&&ZEND_NULL_LABEL,
54630 (void*)&&ZEND_NULL_LABEL,
54631 (void*)&&ZEND_NULL_LABEL,
54632 (void*)&&ZEND_NULL_LABEL,
54633 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CONST_LABEL,
54634 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
54635 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
54636 (void*)&&ZEND_NULL_LABEL,
54637 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CV_LABEL,
54638 (void*)&&ZEND_NULL_LABEL,
54639 (void*)&&ZEND_NULL_LABEL,
54640 (void*)&&ZEND_NULL_LABEL,
54641 (void*)&&ZEND_NULL_LABEL,
54642 (void*)&&ZEND_NULL_LABEL,
54643 (void*)&&ZEND_NULL_LABEL,
54644 (void*)&&ZEND_NULL_LABEL,
54645 (void*)&&ZEND_NULL_LABEL,
54646 (void*)&&ZEND_NULL_LABEL,
54647 (void*)&&ZEND_NULL_LABEL,
54648 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_LABEL,
54649 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
54650 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
54651 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_LABEL,
54652 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_LABEL,
54653 (void*)&&ZEND_NULL_LABEL,
54654 (void*)&&ZEND_NULL_LABEL,
54655 (void*)&&ZEND_NULL_LABEL,
54656 (void*)&&ZEND_NULL_LABEL,
54657 (void*)&&ZEND_NULL_LABEL,
54658 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_LABEL,
54659 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
54660 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
54661 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_LABEL,
54662 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_LABEL,
54663 (void*)&&ZEND_NULL_LABEL,
54664 (void*)&&ZEND_NULL_LABEL,
54665 (void*)&&ZEND_NULL_LABEL,
54666 (void*)&&ZEND_NULL_LABEL,
54667 (void*)&&ZEND_NULL_LABEL,
54668 (void*)&&ZEND_NULL_LABEL,
54669 (void*)&&ZEND_NULL_LABEL,
54670 (void*)&&ZEND_NULL_LABEL,
54671 (void*)&&ZEND_NULL_LABEL,
54672 (void*)&&ZEND_NULL_LABEL,
54673 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_LABEL,
54674 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
54675 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
54676 (void*)&&ZEND_NULL_LABEL,
54677 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_LABEL,
54678 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_LABEL,
54679 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
54680 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
54681 (void*)&&ZEND_NULL_LABEL,
54682 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_LABEL,
54683 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_LABEL,
54684 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
54685 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
54686 (void*)&&ZEND_NULL_LABEL,
54687 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_LABEL,
54688 (void*)&&ZEND_ASSIGN_STATIC_PROP_OP_SPEC_LABEL,
54689 (void*)&&ZEND_NULL_LABEL,
54690 (void*)&&ZEND_NULL_LABEL,
54691 (void*)&&ZEND_NULL_LABEL,
54692 (void*)&&ZEND_NULL_LABEL,
54693 (void*)&&ZEND_NULL_LABEL,
54694 (void*)&&ZEND_NULL_LABEL,
54695 (void*)&&ZEND_NULL_LABEL,
54696 (void*)&&ZEND_NULL_LABEL,
54697 (void*)&&ZEND_NULL_LABEL,
54698 (void*)&&ZEND_NULL_LABEL,
54699 (void*)&&ZEND_NULL_LABEL,
54700 (void*)&&ZEND_NULL_LABEL,
54701 (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_VAR_LABEL,
54702 (void*)&&ZEND_NULL_LABEL,
54703 (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_CV_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_ASSIGN_REF_SPEC_CV_VAR_LABEL,
54712 (void*)&&ZEND_NULL_LABEL,
54713 (void*)&&ZEND_ASSIGN_REF_SPEC_CV_CV_LABEL,
54714 (void*)&&ZEND_QM_ASSIGN_SPEC_CONST_LABEL,
54715 (void*)&&ZEND_QM_ASSIGN_SPEC_TMP_LABEL,
54716 (void*)&&ZEND_QM_ASSIGN_SPEC_VAR_LABEL,
54717 (void*)&&ZEND_NULL_LABEL,
54718 (void*)&&ZEND_QM_ASSIGN_SPEC_CV_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_NULL_LABEL,
54754 (void*)&&ZEND_NULL_LABEL,
54755 (void*)&&ZEND_NULL_LABEL,
54756 (void*)&&ZEND_NULL_LABEL,
54757 (void*)&&ZEND_NULL_LABEL,
54758 (void*)&&ZEND_NULL_LABEL,
54759 (void*)&&ZEND_NULL_LABEL,
54760 (void*)&&ZEND_NULL_LABEL,
54761 (void*)&&ZEND_NULL_LABEL,
54762 (void*)&&ZEND_NULL_LABEL,
54763 (void*)&&ZEND_NULL_LABEL,
54764 (void*)&&ZEND_NULL_LABEL,
54765 (void*)&&ZEND_NULL_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_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
54772 (void*)&&ZEND_NULL_LABEL,
54773 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
54774 (void*)&&ZEND_NULL_LABEL,
54775 (void*)&&ZEND_NULL_LABEL,
54776 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54777 (void*)&&ZEND_NULL_LABEL,
54778 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54779 (void*)&&ZEND_NULL_LABEL,
54780 (void*)&&ZEND_NULL_LABEL,
54781 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54782 (void*)&&ZEND_NULL_LABEL,
54783 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54784 (void*)&&ZEND_NULL_LABEL,
54785 (void*)&&ZEND_NULL_LABEL,
54786 (void*)&&ZEND_NULL_LABEL,
54787 (void*)&&ZEND_NULL_LABEL,
54788 (void*)&&ZEND_NULL_LABEL,
54789 (void*)&&ZEND_NULL_LABEL,
54790 (void*)&&ZEND_NULL_LABEL,
54791 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
54792 (void*)&&ZEND_NULL_LABEL,
54793 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_LABEL,
54794 (void*)&&ZEND_NULL_LABEL,
54795 (void*)&&ZEND_NULL_LABEL,
54796 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
54797 (void*)&&ZEND_NULL_LABEL,
54798 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
54799 (void*)&&ZEND_NULL_LABEL,
54800 (void*)&&ZEND_NULL_LABEL,
54801 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
54802 (void*)&&ZEND_NULL_LABEL,
54803 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
54804 (void*)&&ZEND_NULL_LABEL,
54805 (void*)&&ZEND_NULL_LABEL,
54806 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
54807 (void*)&&ZEND_NULL_LABEL,
54808 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
54809 (void*)&&ZEND_NULL_LABEL,
54810 (void*)&&ZEND_NULL_LABEL,
54811 (void*)&&ZEND_NULL_LABEL,
54812 (void*)&&ZEND_NULL_LABEL,
54813 (void*)&&ZEND_NULL_LABEL,
54814 (void*)&&ZEND_NULL_LABEL,
54815 (void*)&&ZEND_NULL_LABEL,
54816 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
54817 (void*)&&ZEND_NULL_LABEL,
54818 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
54819 (void*)&&ZEND_NULL_LABEL,
54820 (void*)&&ZEND_NULL_LABEL,
54821 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
54822 (void*)&&ZEND_NULL_LABEL,
54823 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_LABEL,
54824 (void*)&&ZEND_NULL_LABEL,
54825 (void*)&&ZEND_NULL_LABEL,
54826 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54827 (void*)&&ZEND_NULL_LABEL,
54828 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54829 (void*)&&ZEND_NULL_LABEL,
54830 (void*)&&ZEND_NULL_LABEL,
54831 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54832 (void*)&&ZEND_NULL_LABEL,
54833 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54834 (void*)&&ZEND_NULL_LABEL,
54835 (void*)&&ZEND_NULL_LABEL,
54836 (void*)&&ZEND_NULL_LABEL,
54837 (void*)&&ZEND_NULL_LABEL,
54838 (void*)&&ZEND_NULL_LABEL,
54839 (void*)&&ZEND_NULL_LABEL,
54840 (void*)&&ZEND_NULL_LABEL,
54841 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_LABEL,
54842 (void*)&&ZEND_NULL_LABEL,
54843 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_LABEL,
54844 (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_LABEL,
54845 (void*)&&ZEND_NULL_LABEL,
54846 (void*)&&ZEND_NULL_LABEL,
54847 (void*)&&ZEND_NULL_LABEL,
54848 (void*)&&ZEND_NULL_LABEL,
54849 (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_LABEL,
54850 (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_LABEL,
54851 (void*)&&ZEND_NULL_LABEL,
54852 (void*)&&ZEND_NULL_LABEL,
54853 (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_LABEL,
54854 (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_USED_LABEL,
54855 (void*)&&ZEND_NULL_LABEL,
54856 (void*)&&ZEND_NULL_LABEL,
54857 (void*)&&ZEND_NULL_LABEL,
54858 (void*)&&ZEND_NULL_LABEL,
54859 (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_LABEL,
54860 (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_LABEL,
54861 (void*)&&ZEND_NULL_LABEL,
54862 (void*)&&ZEND_NULL_LABEL,
54863 (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_LABEL,
54864 (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_LABEL,
54865 (void*)&&ZEND_NULL_LABEL,
54866 (void*)&&ZEND_NULL_LABEL,
54867 (void*)&&ZEND_POST_INC_SPEC_VAR_LABEL,
54868 (void*)&&ZEND_NULL_LABEL,
54869 (void*)&&ZEND_POST_INC_SPEC_CV_LABEL,
54870 (void*)&&ZEND_NULL_LABEL,
54871 (void*)&&ZEND_NULL_LABEL,
54872 (void*)&&ZEND_POST_DEC_SPEC_VAR_LABEL,
54873 (void*)&&ZEND_NULL_LABEL,
54874 (void*)&&ZEND_POST_DEC_SPEC_CV_LABEL,
54875 (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_LABEL,
54876 (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_LABEL,
54877 (void*)&&ZEND_JMP_SPEC_LABEL,
54878 (void*)&&ZEND_JMPZ_SPEC_CONST_LABEL,
54879 (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
54880 (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
54881 (void*)&&ZEND_NULL_LABEL,
54882 (void*)&&ZEND_JMPZ_SPEC_CV_LABEL,
54883 (void*)&&ZEND_JMPNZ_SPEC_CONST_LABEL,
54884 (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
54885 (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
54886 (void*)&&ZEND_NULL_LABEL,
54887 (void*)&&ZEND_JMPNZ_SPEC_CV_LABEL,
54888 (void*)&&ZEND_JMPZ_EX_SPEC_CONST_LABEL,
54889 (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
54890 (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
54891 (void*)&&ZEND_NULL_LABEL,
54892 (void*)&&ZEND_JMPZ_EX_SPEC_CV_LABEL,
54893 (void*)&&ZEND_JMPNZ_EX_SPEC_CONST_LABEL,
54894 (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
54895 (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
54896 (void*)&&ZEND_NULL_LABEL,
54897 (void*)&&ZEND_JMPNZ_EX_SPEC_CV_LABEL,
54898 (void*)&&ZEND_CASE_SPEC_TMPVAR_CONST_LABEL,
54899 (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
54900 (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
54901 (void*)&&ZEND_NULL_LABEL,
54902 (void*)&&ZEND_CASE_SPEC_TMPVAR_CV_LABEL,
54903 (void*)&&ZEND_CHECK_VAR_SPEC_CV_UNUSED_LABEL,
54904 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
54905 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
54906 (void*)&&ZEND_NULL_LABEL,
54907 (void*)&&ZEND_NULL_LABEL,
54908 (void*)&&ZEND_NULL_LABEL,
54909 (void*)&&ZEND_NULL_LABEL,
54910 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_LABEL,
54911 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
54912 (void*)&&ZEND_NULL_LABEL,
54913 (void*)&&ZEND_NULL_LABEL,
54914 (void*)&&ZEND_CAST_SPEC_CONST_LABEL,
54915 (void*)&&ZEND_CAST_SPEC_TMP_LABEL,
54916 (void*)&&ZEND_CAST_SPEC_VAR_LABEL,
54917 (void*)&&ZEND_NULL_LABEL,
54918 (void*)&&ZEND_CAST_SPEC_CV_LABEL,
54919 (void*)&&ZEND_BOOL_SPEC_CONST_LABEL,
54920 (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
54921 (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
54922 (void*)&&ZEND_NULL_LABEL,
54923 (void*)&&ZEND_BOOL_SPEC_CV_LABEL,
54924 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CONST_LABEL,
54925 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
54926 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
54927 (void*)&&ZEND_NULL_LABEL,
54928 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CV_LABEL,
54929 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
54930 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
54931 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
54932 (void*)&&ZEND_NULL_LABEL,
54933 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
54934 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
54935 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
54936 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
54937 (void*)&&ZEND_NULL_LABEL,
54938 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
54939 (void*)&&ZEND_NULL_LABEL,
54940 (void*)&&ZEND_NULL_LABEL,
54941 (void*)&&ZEND_NULL_LABEL,
54942 (void*)&&ZEND_NULL_LABEL,
54943 (void*)&&ZEND_NULL_LABEL,
54944 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CONST_LABEL,
54945 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
54946 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
54947 (void*)&&ZEND_NULL_LABEL,
54948 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CV_LABEL,
54949 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CONST_LABEL,
54950 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
54951 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
54952 (void*)&&ZEND_NULL_LABEL,
54953 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CV_LABEL,
54954 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CONST_LABEL,
54955 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
54956 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
54957 (void*)&&ZEND_NULL_LABEL,
54958 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CV_LABEL,
54959 (void*)&&ZEND_ROPE_END_SPEC_TMP_CONST_LABEL,
54960 (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
54961 (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
54962 (void*)&&ZEND_NULL_LABEL,
54963 (void*)&&ZEND_ROPE_END_SPEC_TMP_CV_LABEL,
54964 (void*)&&ZEND_BEGIN_SILENCE_SPEC_LABEL,
54965 (void*)&&ZEND_END_SILENCE_SPEC_TMP_LABEL,
54966 (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_LABEL,
54967 (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_LABEL,
54968 (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL,
54969 (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
54970 (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
54971 (void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL,
54972 (void*)&&ZEND_RETURN_SPEC_CONST_LABEL,
54973 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
54974 (void*)&&ZEND_RETURN_SPEC_TMP_LABEL,
54975 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
54976 (void*)&&ZEND_RETURN_SPEC_VAR_LABEL,
54977 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
54978 (void*)&&ZEND_NULL_LABEL,
54979 (void*)&&ZEND_NULL_LABEL,
54980 (void*)&&ZEND_RETURN_SPEC_CV_LABEL,
54981 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
54982 (void*)&&ZEND_RECV_SPEC_UNUSED_LABEL,
54983 (void*)&&ZEND_RECV_INIT_SPEC_CONST_LABEL,
54984 (void*)&&ZEND_SEND_VAL_SPEC_CONST_CONST_LABEL,
54985 (void*)&&ZEND_NULL_LABEL,
54986 (void*)&&ZEND_NULL_LABEL,
54987 (void*)&&ZEND_SEND_VAL_SPEC_CONST_UNUSED_LABEL,
54988 (void*)&&ZEND_NULL_LABEL,
54989 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
54990 (void*)&&ZEND_NULL_LABEL,
54991 (void*)&&ZEND_NULL_LABEL,
54992 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL,
54993 (void*)&&ZEND_NULL_LABEL,
54994 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
54995 (void*)&&ZEND_NULL_LABEL,
54996 (void*)&&ZEND_NULL_LABEL,
54997 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_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_NULL_LABEL,
55012 (void*)&&ZEND_NULL_LABEL,
55013 (void*)&&ZEND_NULL_LABEL,
55014 (void*)&&ZEND_NULL_LABEL,
55015 (void*)&&ZEND_NULL_LABEL,
55016 (void*)&&ZEND_NULL_LABEL,
55017 (void*)&&ZEND_NULL_LABEL,
55018 (void*)&&ZEND_NULL_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_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
55030 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
55031 (void*)&&ZEND_NULL_LABEL,
55032 (void*)&&ZEND_NULL_LABEL,
55033 (void*)&&ZEND_NULL_LABEL,
55034 (void*)&&ZEND_NULL_LABEL,
55035 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_LABEL,
55036 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
55037 (void*)&&ZEND_NULL_LABEL,
55038 (void*)&&ZEND_NULL_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_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
55050 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
55051 (void*)&&ZEND_NULL_LABEL,
55052 (void*)&&ZEND_NULL_LABEL,
55053 (void*)&&ZEND_NULL_LABEL,
55054 (void*)&&ZEND_NULL_LABEL,
55055 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_LABEL,
55056 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_LABEL,
55057 (void*)&&ZEND_NULL_LABEL,
55058 (void*)&&ZEND_NULL_LABEL,
55059 (void*)&&ZEND_NULL_LABEL,
55060 (void*)&&ZEND_NULL_LABEL,
55061 (void*)&&ZEND_NULL_LABEL,
55062 (void*)&&ZEND_NULL_LABEL,
55063 (void*)&&ZEND_NULL_LABEL,
55064 (void*)&&ZEND_NULL_LABEL,
55065 (void*)&&ZEND_NULL_LABEL,
55066 (void*)&&ZEND_NULL_LABEL,
55067 (void*)&&ZEND_NULL_LABEL,
55068 (void*)&&ZEND_NULL_LABEL,
55069 (void*)&&ZEND_SEND_REF_SPEC_VAR_CONST_LABEL,
55070 (void*)&&ZEND_NULL_LABEL,
55071 (void*)&&ZEND_NULL_LABEL,
55072 (void*)&&ZEND_SEND_REF_SPEC_VAR_UNUSED_LABEL,
55073 (void*)&&ZEND_NULL_LABEL,
55074 (void*)&&ZEND_NULL_LABEL,
55075 (void*)&&ZEND_NULL_LABEL,
55076 (void*)&&ZEND_NULL_LABEL,
55077 (void*)&&ZEND_NULL_LABEL,
55078 (void*)&&ZEND_NULL_LABEL,
55079 (void*)&&ZEND_SEND_REF_SPEC_CV_CONST_LABEL,
55080 (void*)&&ZEND_NULL_LABEL,
55081 (void*)&&ZEND_NULL_LABEL,
55082 (void*)&&ZEND_SEND_REF_SPEC_CV_UNUSED_LABEL,
55083 (void*)&&ZEND_NULL_LABEL,
55084 (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_LABEL,
55085 (void*)&&ZEND_NULL_LABEL,
55086 (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_LABEL,
55087 (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_LABEL,
55088 (void*)&&ZEND_NULL_LABEL,
55089 (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_LABEL,
55090 (void*)&&ZEND_FREE_SPEC_TMPVAR_LABEL,
55091 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CONST_LABEL,
55092 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
55093 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
55094 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_LABEL,
55095 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CV_LABEL,
55096 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CONST_LABEL,
55097 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
55098 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
55099 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_LABEL,
55100 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CV_LABEL,
55101 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CONST_LABEL,
55102 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
55103 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
55104 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_LABEL,
55105 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CV_LABEL,
55106 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_LABEL,
55107 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
55108 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
55109 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_LABEL,
55110 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CV_LABEL,
55111 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CONST_LABEL,
55112 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
55113 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
55114 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_UNUSED_LABEL,
55115 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CV_LABEL,
55116 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_LABEL,
55117 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
55118 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
55119 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_LABEL,
55120 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_LABEL,
55121 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_LABEL,
55122 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
55123 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
55124 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_LABEL,
55125 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_LABEL,
55126 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_LABEL,
55127 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
55128 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
55129 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_LABEL,
55130 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_LABEL,
55131 (void*)&&ZEND_NULL_LABEL,
55132 (void*)&&ZEND_NULL_LABEL,
55133 (void*)&&ZEND_NULL_LABEL,
55134 (void*)&&ZEND_NULL_LABEL,
55135 (void*)&&ZEND_NULL_LABEL,
55136 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_LABEL,
55137 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
55138 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
55139 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_LABEL,
55140 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_LABEL,
55141 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_LABEL,
55142 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
55143 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
55144 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
55145 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
55146 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
55147 (void*)&&ZEND_NULL_LABEL,
55148 (void*)&&ZEND_NULL_LABEL,
55149 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_LABEL,
55150 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
55151 (void*)&&ZEND_UNSET_VAR_SPEC_CONST_UNUSED_LABEL,
55152 (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
55153 (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
55154 (void*)&&ZEND_NULL_LABEL,
55155 (void*)&&ZEND_UNSET_VAR_SPEC_CV_UNUSED_LABEL,
55156 (void*)&&ZEND_NULL_LABEL,
55157 (void*)&&ZEND_NULL_LABEL,
55158 (void*)&&ZEND_NULL_LABEL,
55159 (void*)&&ZEND_NULL_LABEL,
55160 (void*)&&ZEND_NULL_LABEL,
55161 (void*)&&ZEND_NULL_LABEL,
55162 (void*)&&ZEND_NULL_LABEL,
55163 (void*)&&ZEND_NULL_LABEL,
55164 (void*)&&ZEND_NULL_LABEL,
55165 (void*)&&ZEND_NULL_LABEL,
55166 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CONST_LABEL,
55167 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
55168 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
55169 (void*)&&ZEND_NULL_LABEL,
55170 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CV_LABEL,
55171 (void*)&&ZEND_NULL_LABEL,
55172 (void*)&&ZEND_NULL_LABEL,
55173 (void*)&&ZEND_NULL_LABEL,
55174 (void*)&&ZEND_NULL_LABEL,
55175 (void*)&&ZEND_NULL_LABEL,
55176 (void*)&&ZEND_UNSET_DIM_SPEC_CV_CONST_LABEL,
55177 (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
55178 (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
55179 (void*)&&ZEND_NULL_LABEL,
55180 (void*)&&ZEND_UNSET_DIM_SPEC_CV_CV_LABEL,
55181 (void*)&&ZEND_NULL_LABEL,
55182 (void*)&&ZEND_NULL_LABEL,
55183 (void*)&&ZEND_NULL_LABEL,
55184 (void*)&&ZEND_NULL_LABEL,
55185 (void*)&&ZEND_NULL_LABEL,
55186 (void*)&&ZEND_NULL_LABEL,
55187 (void*)&&ZEND_NULL_LABEL,
55188 (void*)&&ZEND_NULL_LABEL,
55189 (void*)&&ZEND_NULL_LABEL,
55190 (void*)&&ZEND_NULL_LABEL,
55191 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CONST_LABEL,
55192 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
55193 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
55194 (void*)&&ZEND_NULL_LABEL,
55195 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CV_LABEL,
55196 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_LABEL,
55197 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55198 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55199 (void*)&&ZEND_NULL_LABEL,
55200 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CV_LABEL,
55201 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CONST_LABEL,
55202 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
55203 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
55204 (void*)&&ZEND_NULL_LABEL,
55205 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CV_LABEL,
55206 (void*)&&ZEND_FE_RESET_R_SPEC_CONST_LABEL,
55207 (void*)&&ZEND_FE_RESET_R_SPEC_TMP_LABEL,
55208 (void*)&&ZEND_FE_RESET_R_SPEC_VAR_LABEL,
55209 (void*)&&ZEND_NULL_LABEL,
55210 (void*)&&ZEND_FE_RESET_R_SPEC_CV_LABEL,
55211 (void*)&&ZEND_FE_FETCH_R_SPEC_VAR_LABEL,
55212 (void*)&&ZEND_EXIT_SPEC_LABEL,
55213 (void*)&&ZEND_FETCH_R_SPEC_CONST_UNUSED_LABEL,
55214 (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
55215 (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
55216 (void*)&&ZEND_NULL_LABEL,
55217 (void*)&&ZEND_FETCH_R_SPEC_CV_UNUSED_LABEL,
55218 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CONST_LABEL,
55219 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
55220 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
55221 (void*)&&ZEND_NULL_LABEL,
55222 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CV_LABEL,
55223 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
55224 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
55225 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
55226 (void*)&&ZEND_NULL_LABEL,
55227 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
55228 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
55229 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
55230 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
55231 (void*)&&ZEND_NULL_LABEL,
55232 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
55233 (void*)&&ZEND_NULL_LABEL,
55234 (void*)&&ZEND_NULL_LABEL,
55235 (void*)&&ZEND_NULL_LABEL,
55236 (void*)&&ZEND_NULL_LABEL,
55237 (void*)&&ZEND_NULL_LABEL,
55238 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CONST_LABEL,
55239 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
55240 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
55241 (void*)&&ZEND_NULL_LABEL,
55242 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CV_LABEL,
55243 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_LABEL,
55244 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
55245 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
55246 (void*)&&ZEND_NULL_LABEL,
55247 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CV_LABEL,
55248 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
55249 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
55250 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
55251 (void*)&&ZEND_NULL_LABEL,
55252 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
55253 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
55254 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
55255 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
55256 (void*)&&ZEND_NULL_LABEL,
55257 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
55258 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_LABEL,
55259 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
55260 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
55261 (void*)&&ZEND_NULL_LABEL,
55262 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_LABEL,
55263 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CONST_LABEL,
55264 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
55265 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
55266 (void*)&&ZEND_NULL_LABEL,
55267 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CV_LABEL,
55268 (void*)&&ZEND_FETCH_W_SPEC_CONST_UNUSED_LABEL,
55269 (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
55270 (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
55271 (void*)&&ZEND_NULL_LABEL,
55272 (void*)&&ZEND_FETCH_W_SPEC_CV_UNUSED_LABEL,
55273 (void*)&&ZEND_NULL_LABEL,
55274 (void*)&&ZEND_NULL_LABEL,
55275 (void*)&&ZEND_NULL_LABEL,
55276 (void*)&&ZEND_NULL_LABEL,
55277 (void*)&&ZEND_NULL_LABEL,
55278 (void*)&&ZEND_NULL_LABEL,
55279 (void*)&&ZEND_NULL_LABEL,
55280 (void*)&&ZEND_NULL_LABEL,
55281 (void*)&&ZEND_NULL_LABEL,
55282 (void*)&&ZEND_NULL_LABEL,
55283 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CONST_LABEL,
55284 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
55285 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
55286 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_LABEL,
55287 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CV_LABEL,
55288 (void*)&&ZEND_NULL_LABEL,
55289 (void*)&&ZEND_NULL_LABEL,
55290 (void*)&&ZEND_NULL_LABEL,
55291 (void*)&&ZEND_NULL_LABEL,
55292 (void*)&&ZEND_NULL_LABEL,
55293 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CONST_LABEL,
55294 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
55295 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
55296 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_LABEL,
55297 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CV_LABEL,
55298 (void*)&&ZEND_NULL_LABEL,
55299 (void*)&&ZEND_NULL_LABEL,
55300 (void*)&&ZEND_NULL_LABEL,
55301 (void*)&&ZEND_NULL_LABEL,
55302 (void*)&&ZEND_NULL_LABEL,
55303 (void*)&&ZEND_NULL_LABEL,
55304 (void*)&&ZEND_NULL_LABEL,
55305 (void*)&&ZEND_NULL_LABEL,
55306 (void*)&&ZEND_NULL_LABEL,
55307 (void*)&&ZEND_NULL_LABEL,
55308 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_LABEL,
55309 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
55310 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
55311 (void*)&&ZEND_NULL_LABEL,
55312 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CV_LABEL,
55313 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_LABEL,
55314 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
55315 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
55316 (void*)&&ZEND_NULL_LABEL,
55317 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_LABEL,
55318 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CONST_LABEL,
55319 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
55320 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
55321 (void*)&&ZEND_NULL_LABEL,
55322 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CV_LABEL,
55323 (void*)&&ZEND_FETCH_RW_SPEC_CONST_UNUSED_LABEL,
55324 (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
55325 (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
55326 (void*)&&ZEND_NULL_LABEL,
55327 (void*)&&ZEND_FETCH_RW_SPEC_CV_UNUSED_LABEL,
55328 (void*)&&ZEND_NULL_LABEL,
55329 (void*)&&ZEND_NULL_LABEL,
55330 (void*)&&ZEND_NULL_LABEL,
55331 (void*)&&ZEND_NULL_LABEL,
55332 (void*)&&ZEND_NULL_LABEL,
55333 (void*)&&ZEND_NULL_LABEL,
55334 (void*)&&ZEND_NULL_LABEL,
55335 (void*)&&ZEND_NULL_LABEL,
55336 (void*)&&ZEND_NULL_LABEL,
55337 (void*)&&ZEND_NULL_LABEL,
55338 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_LABEL,
55339 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
55340 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
55341 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_LABEL,
55342 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CV_LABEL,
55343 (void*)&&ZEND_NULL_LABEL,
55344 (void*)&&ZEND_NULL_LABEL,
55345 (void*)&&ZEND_NULL_LABEL,
55346 (void*)&&ZEND_NULL_LABEL,
55347 (void*)&&ZEND_NULL_LABEL,
55348 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CONST_LABEL,
55349 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
55350 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
55351 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_LABEL,
55352 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CV_LABEL,
55353 (void*)&&ZEND_NULL_LABEL,
55354 (void*)&&ZEND_NULL_LABEL,
55355 (void*)&&ZEND_NULL_LABEL,
55356 (void*)&&ZEND_NULL_LABEL,
55357 (void*)&&ZEND_NULL_LABEL,
55358 (void*)&&ZEND_NULL_LABEL,
55359 (void*)&&ZEND_NULL_LABEL,
55360 (void*)&&ZEND_NULL_LABEL,
55361 (void*)&&ZEND_NULL_LABEL,
55362 (void*)&&ZEND_NULL_LABEL,
55363 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_LABEL,
55364 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
55365 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
55366 (void*)&&ZEND_NULL_LABEL,
55367 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_LABEL,
55368 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_LABEL,
55369 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
55370 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
55371 (void*)&&ZEND_NULL_LABEL,
55372 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_LABEL,
55373 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_LABEL,
55374 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
55375 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
55376 (void*)&&ZEND_NULL_LABEL,
55377 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CV_LABEL,
55378 (void*)&&ZEND_FETCH_IS_SPEC_CONST_UNUSED_LABEL,
55379 (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
55380 (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
55381 (void*)&&ZEND_NULL_LABEL,
55382 (void*)&&ZEND_FETCH_IS_SPEC_CV_UNUSED_LABEL,
55383 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_LABEL,
55384 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
55385 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
55386 (void*)&&ZEND_NULL_LABEL,
55387 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CV_LABEL,
55388 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
55389 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55390 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55391 (void*)&&ZEND_NULL_LABEL,
55392 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
55393 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
55394 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55395 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55396 (void*)&&ZEND_NULL_LABEL,
55397 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
55398 (void*)&&ZEND_NULL_LABEL,
55399 (void*)&&ZEND_NULL_LABEL,
55400 (void*)&&ZEND_NULL_LABEL,
55401 (void*)&&ZEND_NULL_LABEL,
55402 (void*)&&ZEND_NULL_LABEL,
55403 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CONST_LABEL,
55404 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
55405 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
55406 (void*)&&ZEND_NULL_LABEL,
55407 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CV_LABEL,
55408 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_LABEL,
55409 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
55410 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
55411 (void*)&&ZEND_NULL_LABEL,
55412 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_LABEL,
55413 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
55414 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55415 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55416 (void*)&&ZEND_NULL_LABEL,
55417 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
55418 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
55419 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55420 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55421 (void*)&&ZEND_NULL_LABEL,
55422 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
55423 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_LABEL,
55424 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
55425 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
55426 (void*)&&ZEND_NULL_LABEL,
55427 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_LABEL,
55428 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_LABEL,
55429 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
55430 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
55431 (void*)&&ZEND_NULL_LABEL,
55432 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CV_LABEL,
55433 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
55434 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
55435 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
55436 (void*)&&ZEND_NULL_LABEL,
55437 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
55438 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_LABEL,
55439 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
55440 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
55441 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
55442 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_LABEL,
55443 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_LABEL,
55444 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
55445 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
55446 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_LABEL,
55447 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_LABEL,
55448 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_LABEL,
55449 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
55450 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
55451 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
55452 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_LABEL,
55453 (void*)&&ZEND_NULL_LABEL,
55454 (void*)&&ZEND_NULL_LABEL,
55455 (void*)&&ZEND_NULL_LABEL,
55456 (void*)&&ZEND_NULL_LABEL,
55457 (void*)&&ZEND_NULL_LABEL,
55458 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_LABEL,
55459 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
55460 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
55461 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
55462 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_LABEL,
55463 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_LABEL,
55464 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
55465 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
55466 (void*)&&ZEND_NULL_LABEL,
55467 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_LABEL,
55468 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_LABEL,
55469 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
55470 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
55471 (void*)&&ZEND_NULL_LABEL,
55472 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_LABEL,
55473 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_LABEL,
55474 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
55475 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
55476 (void*)&&ZEND_NULL_LABEL,
55477 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_LABEL,
55478 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
55479 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
55480 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
55481 (void*)&&ZEND_NULL_LABEL,
55482 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_LABEL,
55483 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_LABEL,
55484 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
55485 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
55486 (void*)&&ZEND_NULL_LABEL,
55487 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_LABEL,
55488 (void*)&&ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_LABEL,
55489 (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
55490 (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
55491 (void*)&&ZEND_NULL_LABEL,
55492 (void*)&&ZEND_FETCH_UNSET_SPEC_CV_UNUSED_LABEL,
55493 (void*)&&ZEND_NULL_LABEL,
55494 (void*)&&ZEND_NULL_LABEL,
55495 (void*)&&ZEND_NULL_LABEL,
55496 (void*)&&ZEND_NULL_LABEL,
55497 (void*)&&ZEND_NULL_LABEL,
55498 (void*)&&ZEND_NULL_LABEL,
55499 (void*)&&ZEND_NULL_LABEL,
55500 (void*)&&ZEND_NULL_LABEL,
55501 (void*)&&ZEND_NULL_LABEL,
55502 (void*)&&ZEND_NULL_LABEL,
55503 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_LABEL,
55504 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
55505 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
55506 (void*)&&ZEND_NULL_LABEL,
55507 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_LABEL,
55508 (void*)&&ZEND_NULL_LABEL,
55509 (void*)&&ZEND_NULL_LABEL,
55510 (void*)&&ZEND_NULL_LABEL,
55511 (void*)&&ZEND_NULL_LABEL,
55512 (void*)&&ZEND_NULL_LABEL,
55513 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_LABEL,
55514 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
55515 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
55516 (void*)&&ZEND_NULL_LABEL,
55517 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_LABEL,
55518 (void*)&&ZEND_NULL_LABEL,
55519 (void*)&&ZEND_NULL_LABEL,
55520 (void*)&&ZEND_NULL_LABEL,
55521 (void*)&&ZEND_NULL_LABEL,
55522 (void*)&&ZEND_NULL_LABEL,
55523 (void*)&&ZEND_NULL_LABEL,
55524 (void*)&&ZEND_NULL_LABEL,
55525 (void*)&&ZEND_NULL_LABEL,
55526 (void*)&&ZEND_NULL_LABEL,
55527 (void*)&&ZEND_NULL_LABEL,
55528 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_LABEL,
55529 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
55530 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
55531 (void*)&&ZEND_NULL_LABEL,
55532 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_LABEL,
55533 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_LABEL,
55534 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
55535 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
55536 (void*)&&ZEND_NULL_LABEL,
55537 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_LABEL,
55538 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_LABEL,
55539 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
55540 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
55541 (void*)&&ZEND_NULL_LABEL,
55542 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_LABEL,
55543 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CONST_LABEL,
55544 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
55545 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
55546 (void*)&&ZEND_NULL_LABEL,
55547 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CV_LABEL,
55548 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
55549 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55550 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55551 (void*)&&ZEND_NULL_LABEL,
55552 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
55553 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
55554 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55555 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55556 (void*)&&ZEND_NULL_LABEL,
55557 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
55558 (void*)&&ZEND_NULL_LABEL,
55559 (void*)&&ZEND_NULL_LABEL,
55560 (void*)&&ZEND_NULL_LABEL,
55561 (void*)&&ZEND_NULL_LABEL,
55562 (void*)&&ZEND_NULL_LABEL,
55563 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
55564 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55565 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55566 (void*)&&ZEND_NULL_LABEL,
55567 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
55568 (void*)&&ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_LABEL,
55569 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
55570 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
55571 (void*)&&ZEND_NULL_LABEL,
55572 (void*)&&ZEND_NULL_LABEL,
55573 (void*)&&ZEND_NULL_LABEL,
55574 (void*)&&ZEND_NULL_LABEL,
55575 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_LABEL,
55576 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_LABEL,
55577 (void*)&&ZEND_NULL_LABEL,
55578 (void*)&&ZEND_NULL_LABEL,
55579 (void*)&&ZEND_EXT_STMT_SPEC_LABEL,
55580 (void*)&&ZEND_EXT_FCALL_BEGIN_SPEC_LABEL,
55581 (void*)&&ZEND_EXT_FCALL_END_SPEC_LABEL,
55582 (void*)&&ZEND_EXT_NOP_SPEC_LABEL,
55583 (void*)&&ZEND_TICKS_SPEC_LABEL,
55584 (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_LABEL,
55585 (void*)&&ZEND_NULL_LABEL,
55586 (void*)&&ZEND_NULL_LABEL,
55587 (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_LABEL,
55588 (void*)&&ZEND_NULL_LABEL,
55589 (void*)&&ZEND_CATCH_SPEC_CONST_LABEL,
55590 (void*)&&ZEND_THROW_SPEC_CONST_LABEL,
55591 (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
55592 (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
55593 (void*)&&ZEND_NULL_LABEL,
55594 (void*)&&ZEND_THROW_SPEC_CV_LABEL,
55595 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_LABEL,
55596 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
55597 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
55598 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_LABEL,
55599 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CV_LABEL,
55600 (void*)&&ZEND_CLONE_SPEC_CONST_LABEL,
55601 (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
55602 (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
55603 (void*)&&ZEND_CLONE_SPEC_UNUSED_LABEL,
55604 (void*)&&ZEND_CLONE_SPEC_CV_LABEL,
55605 (void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_LABEL,
55606 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
55607 (void*)&&ZEND_RETURN_BY_REF_SPEC_TMP_LABEL,
55608 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
55609 (void*)&&ZEND_RETURN_BY_REF_SPEC_VAR_LABEL,
55610 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
55611 (void*)&&ZEND_NULL_LABEL,
55612 (void*)&&ZEND_NULL_LABEL,
55613 (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL,
55614 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
55615 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL,
55616 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
55617 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
55618 (void*)&&ZEND_NULL_LABEL,
55619 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_LABEL,
55620 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
55621 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
55622 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
55623 (void*)&&ZEND_NULL_LABEL,
55624 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
55625 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
55626 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
55627 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
55628 (void*)&&ZEND_NULL_LABEL,
55629 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
55630 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
55631 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
55632 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
55633 (void*)&&ZEND_NULL_LABEL,
55634 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
55635 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_LABEL,
55636 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
55637 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
55638 (void*)&&ZEND_NULL_LABEL,
55639 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_LABEL,
55640 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_LABEL,
55641 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
55642 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
55643 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_LABEL,
55644 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_LABEL,
55645 (void*)&&ZEND_NULL_LABEL,
55646 (void*)&&ZEND_NULL_LABEL,
55647 (void*)&&ZEND_NULL_LABEL,
55648 (void*)&&ZEND_NULL_LABEL,
55649 (void*)&&ZEND_NULL_LABEL,
55650 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_LABEL,
55651 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
55652 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
55653 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_LABEL,
55654 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_LABEL,
55655 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
55656 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
55657 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
55658 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_LABEL,
55659 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
55660 (void*)&&ZEND_NULL_LABEL,
55661 (void*)&&ZEND_NULL_LABEL,
55662 (void*)&&ZEND_NULL_LABEL,
55663 (void*)&&ZEND_NULL_LABEL,
55664 (void*)&&ZEND_NULL_LABEL,
55665 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_LABEL,
55666 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
55667 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
55668 (void*)&&ZEND_NULL_LABEL,
55669 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_LABEL,
55670 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_LABEL,
55671 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
55672 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
55673 (void*)&&ZEND_NULL_LABEL,
55674 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_LABEL,
55675 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
55676 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55677 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55678 (void*)&&ZEND_NULL_LABEL,
55679 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
55680 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
55681 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55682 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55683 (void*)&&ZEND_NULL_LABEL,
55684 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
55685 (void*)&&ZEND_NULL_LABEL,
55686 (void*)&&ZEND_NULL_LABEL,
55687 (void*)&&ZEND_NULL_LABEL,
55688 (void*)&&ZEND_NULL_LABEL,
55689 (void*)&&ZEND_NULL_LABEL,
55690 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_LABEL,
55691 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
55692 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
55693 (void*)&&ZEND_NULL_LABEL,
55694 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_LABEL,
55695 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
55696 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
55697 (void*)&&ZEND_NULL_LABEL,
55698 (void*)&&ZEND_NULL_LABEL,
55699 (void*)&&ZEND_NULL_LABEL,
55700 (void*)&&ZEND_NULL_LABEL,
55701 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_LABEL,
55702 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_LABEL,
55703 (void*)&&ZEND_NULL_LABEL,
55704 (void*)&&ZEND_NULL_LABEL,
55705 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
55706 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
55707 (void*)&&ZEND_NULL_LABEL,
55708 (void*)&&ZEND_NULL_LABEL,
55709 (void*)&&ZEND_NULL_LABEL,
55710 (void*)&&ZEND_NULL_LABEL,
55711 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_LABEL,
55712 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_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_NULL_LABEL,
55738 (void*)&&ZEND_NULL_LABEL,
55739 (void*)&&ZEND_NULL_LABEL,
55740 (void*)&&ZEND_NULL_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_NULL_LABEL,
55748 (void*)&&ZEND_NULL_LABEL,
55749 (void*)&&ZEND_NULL_LABEL,
55750 (void*)&&ZEND_NULL_LABEL,
55751 (void*)&&ZEND_NULL_LABEL,
55752 (void*)&&ZEND_NULL_LABEL,
55753 (void*)&&ZEND_NULL_LABEL,
55754 (void*)&&ZEND_NULL_LABEL,
55755 (void*)&&ZEND_SEND_VAR_SPEC_VAR_CONST_LABEL,
55756 (void*)&&ZEND_NULL_LABEL,
55757 (void*)&&ZEND_NULL_LABEL,
55758 (void*)&&ZEND_SEND_VAR_SPEC_VAR_UNUSED_LABEL,
55759 (void*)&&ZEND_NULL_LABEL,
55760 (void*)&&ZEND_NULL_LABEL,
55761 (void*)&&ZEND_NULL_LABEL,
55762 (void*)&&ZEND_NULL_LABEL,
55763 (void*)&&ZEND_NULL_LABEL,
55764 (void*)&&ZEND_NULL_LABEL,
55765 (void*)&&ZEND_SEND_VAR_SPEC_CV_CONST_LABEL,
55766 (void*)&&ZEND_NULL_LABEL,
55767 (void*)&&ZEND_NULL_LABEL,
55768 (void*)&&ZEND_SEND_VAR_SPEC_CV_UNUSED_LABEL,
55769 (void*)&&ZEND_NULL_LABEL,
55770 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_LABEL,
55771 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
55772 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
55773 (void*)&&ZEND_NULL_LABEL,
55774 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL,
55775 (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL,
55776 (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL,
55777 (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL,
55778 (void*)&&ZEND_SEND_USER_SPEC_VAR_LABEL,
55779 (void*)&&ZEND_NULL_LABEL,
55780 (void*)&&ZEND_SEND_USER_SPEC_CV_LABEL,
55781 (void*)&&ZEND_STRLEN_SPEC_CONST_LABEL,
55782 (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
55783 (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
55784 (void*)&&ZEND_NULL_LABEL,
55785 (void*)&&ZEND_STRLEN_SPEC_CV_LABEL,
55786 (void*)&&ZEND_DEFINED_SPEC_CONST_LABEL,
55787 (void*)&&ZEND_TYPE_CHECK_SPEC_CONST_LABEL,
55788 (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
55789 (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
55790 (void*)&&ZEND_NULL_LABEL,
55791 (void*)&&ZEND_TYPE_CHECK_SPEC_CV_LABEL,
55792 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_LABEL,
55793 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_LABEL,
55794 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_LABEL,
55795 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_LABEL,
55796 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_LABEL,
55797 (void*)&&ZEND_FE_RESET_RW_SPEC_CONST_LABEL,
55798 (void*)&&ZEND_FE_RESET_RW_SPEC_TMP_LABEL,
55799 (void*)&&ZEND_FE_RESET_RW_SPEC_VAR_LABEL,
55800 (void*)&&ZEND_NULL_LABEL,
55801 (void*)&&ZEND_FE_RESET_RW_SPEC_CV_LABEL,
55802 (void*)&&ZEND_FE_FETCH_RW_SPEC_VAR_LABEL,
55803 (void*)&&ZEND_FE_FREE_SPEC_TMPVAR_LABEL,
55804 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_LABEL,
55805 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
55806 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
55807 (void*)&&ZEND_NULL_LABEL,
55808 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CV_LABEL,
55809 (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_LABEL,
55810 (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_USED_LABEL,
55811 (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
55812 (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
55813 (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_LABEL,
55814 (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_LABEL,
55815 (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
55816 (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
55817 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_LABEL,
55818 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_LABEL,
55819 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_LABEL,
55820 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_LABEL,
55821 (void*)&&ZEND_NULL_LABEL,
55822 (void*)&&ZEND_NULL_LABEL,
55823 (void*)&&ZEND_NULL_LABEL,
55824 (void*)&&ZEND_NULL_LABEL,
55825 (void*)&&ZEND_NULL_LABEL,
55826 (void*)&&ZEND_NULL_LABEL,
55827 (void*)&&ZEND_NULL_LABEL,
55828 (void*)&&ZEND_NULL_LABEL,
55829 (void*)&&ZEND_NULL_LABEL,
55830 (void*)&&ZEND_NULL_LABEL,
55831 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_LABEL,
55832 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
55833 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
55834 (void*)&&ZEND_NULL_LABEL,
55835 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CV_LABEL,
55836 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
55837 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55838 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55839 (void*)&&ZEND_NULL_LABEL,
55840 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_LABEL,
55841 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CONST_LABEL,
55842 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
55843 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
55844 (void*)&&ZEND_NULL_LABEL,
55845 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CV_LABEL,
55846 (void*)&&ZEND_NULL_LABEL,
55847 (void*)&&ZEND_NULL_LABEL,
55848 (void*)&&ZEND_NULL_LABEL,
55849 (void*)&&ZEND_NULL_LABEL,
55850 (void*)&&ZEND_NULL_LABEL,
55851 (void*)&&ZEND_NULL_LABEL,
55852 (void*)&&ZEND_NULL_LABEL,
55853 (void*)&&ZEND_NULL_LABEL,
55854 (void*)&&ZEND_NULL_LABEL,
55855 (void*)&&ZEND_NULL_LABEL,
55856 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CONST_LABEL,
55857 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
55858 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
55859 (void*)&&ZEND_NULL_LABEL,
55860 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CV_LABEL,
55861 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
55862 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55863 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55864 (void*)&&ZEND_NULL_LABEL,
55865 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_LABEL,
55866 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CONST_LABEL,
55867 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
55868 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
55869 (void*)&&ZEND_NULL_LABEL,
55870 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CV_LABEL,
55871 (void*)&&ZEND_ECHO_SPEC_CONST_LABEL,
55872 (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
55873 (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
55874 (void*)&&ZEND_NULL_LABEL,
55875 (void*)&&ZEND_ECHO_SPEC_CV_LABEL,
55876 (void*)&&ZEND_NULL_LABEL,
55877 (void*)&&ZEND_NULL_LABEL,
55878 (void*)&&ZEND_NULL_LABEL,
55879 (void*)&&ZEND_NULL_LABEL,
55880 (void*)&&ZEND_NULL_LABEL,
55881 (void*)&&ZEND_NULL_LABEL,
55882 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
55883 (void*)&&ZEND_NULL_LABEL,
55884 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
55885 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
55886 (void*)&&ZEND_NULL_LABEL,
55887 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
55888 (void*)&&ZEND_NULL_LABEL,
55889 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
55890 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
55891 (void*)&&ZEND_NULL_LABEL,
55892 (void*)&&ZEND_NULL_LABEL,
55893 (void*)&&ZEND_NULL_LABEL,
55894 (void*)&&ZEND_NULL_LABEL,
55895 (void*)&&ZEND_NULL_LABEL,
55896 (void*)&&ZEND_NULL_LABEL,
55897 (void*)&&ZEND_INSTANCEOF_SPEC_CV_CONST_LABEL,
55898 (void*)&&ZEND_NULL_LABEL,
55899 (void*)&&ZEND_INSTANCEOF_SPEC_CV_VAR_LABEL,
55900 (void*)&&ZEND_INSTANCEOF_SPEC_CV_UNUSED_LABEL,
55901 (void*)&&ZEND_NULL_LABEL,
55902 (void*)&&ZEND_GENERATOR_CREATE_SPEC_LABEL,
55903 (void*)&&ZEND_NULL_LABEL,
55904 (void*)&&ZEND_NULL_LABEL,
55905 (void*)&&ZEND_MAKE_REF_SPEC_VAR_UNUSED_LABEL,
55906 (void*)&&ZEND_NULL_LABEL,
55907 (void*)&&ZEND_MAKE_REF_SPEC_CV_UNUSED_LABEL,
55908 (void*)&&ZEND_DECLARE_FUNCTION_SPEC_LABEL,
55909 (void*)&&ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_LABEL,
55910 (void*)&&ZEND_DECLARE_CONST_SPEC_CONST_CONST_LABEL,
55911 (void*)&&ZEND_DECLARE_CLASS_SPEC_CONST_LABEL,
55912 (void*)&&ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_LABEL,
55913 (void*)&&ZEND_DECLARE_ANON_CLASS_SPEC_LABEL,
55914 (void*)&&ZEND_ADD_ARRAY_UNPACK_SPEC_LABEL,
55915 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_LABEL,
55916 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
55917 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
55918 (void*)&&ZEND_NULL_LABEL,
55919 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_LABEL,
55920 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
55921 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55922 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55923 (void*)&&ZEND_NULL_LABEL,
55924 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
55925 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
55926 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55927 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55928 (void*)&&ZEND_NULL_LABEL,
55929 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
55930 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_LABEL,
55931 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55932 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55933 (void*)&&ZEND_NULL_LABEL,
55934 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_LABEL,
55935 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_LABEL,
55936 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
55937 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
55938 (void*)&&ZEND_NULL_LABEL,
55939 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_LABEL,
55940 (void*)&&ZEND_HANDLE_EXCEPTION_SPEC_LABEL,
55941 (void*)&&ZEND_USER_OPCODE_SPEC_LABEL,
55942 (void*)&&ZEND_ASSERT_CHECK_SPEC_LABEL,
55943 (void*)&&ZEND_JMP_SET_SPEC_CONST_LABEL,
55944 (void*)&&ZEND_JMP_SET_SPEC_TMP_LABEL,
55945 (void*)&&ZEND_JMP_SET_SPEC_VAR_LABEL,
55946 (void*)&&ZEND_NULL_LABEL,
55947 (void*)&&ZEND_JMP_SET_SPEC_CV_LABEL,
55948 (void*)&&ZEND_UNSET_CV_SPEC_CV_UNUSED_LABEL,
55949 (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_LABEL,
55950 (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_LABEL,
55951 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CONST_LABEL,
55952 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
55953 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
55954 (void*)&&ZEND_NULL_LABEL,
55955 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CV_LABEL,
55956 (void*)&&ZEND_SEPARATE_SPEC_VAR_UNUSED_LABEL,
55957 (void*)&&ZEND_NULL_LABEL,
55958 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
55959 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
55960 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL,
55961 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_CV_LABEL,
55962 (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL,
55963 (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_LABEL,
55964 (void*)&&ZEND_DISCARD_EXCEPTION_SPEC_LABEL,
55965 (void*)&&ZEND_YIELD_SPEC_CONST_CONST_LABEL,
55966 (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
55967 (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
55968 (void*)&&ZEND_YIELD_SPEC_CONST_UNUSED_LABEL,
55969 (void*)&&ZEND_YIELD_SPEC_CONST_CV_LABEL,
55970 (void*)&&ZEND_YIELD_SPEC_TMP_CONST_LABEL,
55971 (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
55972 (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
55973 (void*)&&ZEND_YIELD_SPEC_TMP_UNUSED_LABEL,
55974 (void*)&&ZEND_YIELD_SPEC_TMP_CV_LABEL,
55975 (void*)&&ZEND_YIELD_SPEC_VAR_CONST_LABEL,
55976 (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
55977 (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
55978 (void*)&&ZEND_YIELD_SPEC_VAR_UNUSED_LABEL,
55979 (void*)&&ZEND_YIELD_SPEC_VAR_CV_LABEL,
55980 (void*)&&ZEND_YIELD_SPEC_UNUSED_CONST_LABEL,
55981 (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
55982 (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
55983 (void*)&&ZEND_YIELD_SPEC_UNUSED_UNUSED_LABEL,
55984 (void*)&&ZEND_YIELD_SPEC_UNUSED_CV_LABEL,
55985 (void*)&&ZEND_YIELD_SPEC_CV_CONST_LABEL,
55986 (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
55987 (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
55988 (void*)&&ZEND_YIELD_SPEC_CV_UNUSED_LABEL,
55989 (void*)&&ZEND_YIELD_SPEC_CV_CV_LABEL,
55990 (void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_LABEL,
55991 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
55992 (void*)&&ZEND_GENERATOR_RETURN_SPEC_TMP_LABEL,
55993 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
55994 (void*)&&ZEND_GENERATOR_RETURN_SPEC_VAR_LABEL,
55995 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
55996 (void*)&&ZEND_NULL_LABEL,
55997 (void*)&&ZEND_NULL_LABEL,
55998 (void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_LABEL,
55999 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
56000 (void*)&&ZEND_FAST_CALL_SPEC_LABEL,
56001 (void*)&&ZEND_FAST_RET_SPEC_LABEL,
56002 (void*)&&ZEND_RECV_VARIADIC_SPEC_UNUSED_LABEL,
56003 (void*)&&ZEND_SEND_UNPACK_SPEC_LABEL,
56004 (void*)&&ZEND_YIELD_FROM_SPEC_CONST_LABEL,
56005 (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
56006 (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
56007 (void*)&&ZEND_NULL_LABEL,
56008 (void*)&&ZEND_YIELD_FROM_SPEC_CV_LABEL,
56009 (void*)&&ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_LABEL,
56010 (void*)&&ZEND_BIND_GLOBAL_SPEC_CV_CONST_LABEL,
56011 (void*)&&ZEND_COALESCE_SPEC_CONST_LABEL,
56012 (void*)&&ZEND_COALESCE_SPEC_TMP_LABEL,
56013 (void*)&&ZEND_COALESCE_SPEC_VAR_LABEL,
56014 (void*)&&ZEND_NULL_LABEL,
56015 (void*)&&ZEND_COALESCE_SPEC_CV_LABEL,
56016 (void*)&&ZEND_SPACESHIP_SPEC_CONST_CONST_LABEL,
56017 (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
56018 (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
56019 (void*)&&ZEND_NULL_LABEL,
56020 (void*)&&ZEND_SPACESHIP_SPEC_CONST_CV_LABEL,
56021 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
56022 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
56023 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
56024 (void*)&&ZEND_NULL_LABEL,
56025 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
56026 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
56027 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
56028 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
56029 (void*)&&ZEND_NULL_LABEL,
56030 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
56031 (void*)&&ZEND_NULL_LABEL,
56032 (void*)&&ZEND_NULL_LABEL,
56033 (void*)&&ZEND_NULL_LABEL,
56034 (void*)&&ZEND_NULL_LABEL,
56035 (void*)&&ZEND_NULL_LABEL,
56036 (void*)&&ZEND_SPACESHIP_SPEC_CV_CONST_LABEL,
56037 (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
56038 (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
56039 (void*)&&ZEND_NULL_LABEL,
56040 (void*)&&ZEND_SPACESHIP_SPEC_CV_CV_LABEL,
56041 (void*)&&ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_LABEL,
56042 (void*)&&ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_LABEL,
56043 (void*)&&ZEND_NULL_LABEL,
56044 (void*)&&ZEND_NULL_LABEL,
56045 (void*)&&ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_LABEL,
56046 (void*)&&ZEND_NULL_LABEL,
56047 (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_LABEL,
56048 (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_LABEL,
56049 (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_LABEL,
56050 (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_LABEL,
56051 (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_LABEL,
56052 (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_LABEL,
56053 (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_LABEL,
56054 (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_LABEL,
56055 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_LABEL,
56056 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
56057 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
56058 (void*)&&ZEND_NULL_LABEL,
56059 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
56060 (void*)&&ZEND_NULL_LABEL,
56061 (void*)&&ZEND_NULL_LABEL,
56062 (void*)&&ZEND_NULL_LABEL,
56063 (void*)&&ZEND_NULL_LABEL,
56064 (void*)&&ZEND_NULL_LABEL,
56065 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_LABEL,
56066 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
56067 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
56068 (void*)&&ZEND_NULL_LABEL,
56069 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
56070 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_LABEL,
56071 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
56072 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
56073 (void*)&&ZEND_NULL_LABEL,
56074 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
56075 (void*)&&ZEND_NULL_LABEL,
56076 (void*)&&ZEND_NULL_LABEL,
56077 (void*)&&ZEND_NULL_LABEL,
56078 (void*)&&ZEND_NULL_LABEL,
56079 (void*)&&ZEND_NULL_LABEL,
56080 (void*)&&ZEND_BIND_LEXICAL_SPEC_TMP_CV_LABEL,
56081 (void*)&&ZEND_BIND_STATIC_SPEC_CV_LABEL,
56082 (void*)&&ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_LABEL,
56083 (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_LABEL,
56084 (void*)&&ZEND_NULL_LABEL,
56085 (void*)&&ZEND_NULL_LABEL,
56086 (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
56087 (void*)&&ZEND_NULL_LABEL,
56088 (void*)&&ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_LABEL,
56089 (void*)&&ZEND_SWITCH_LONG_SPEC_CONST_CONST_LABEL,
56090 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
56091 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
56092 (void*)&&ZEND_NULL_LABEL,
56093 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
56094 (void*)&&ZEND_SWITCH_STRING_SPEC_CONST_CONST_LABEL,
56095 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
56096 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
56097 (void*)&&ZEND_NULL_LABEL,
56098 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
56099 (void*)&&ZEND_IN_ARRAY_SPEC_CONST_CONST_LABEL,
56100 (void*)&&ZEND_IN_ARRAY_SPEC_TMP_CONST_LABEL,
56101 (void*)&&ZEND_IN_ARRAY_SPEC_VAR_CONST_LABEL,
56102 (void*)&&ZEND_NULL_LABEL,
56103 (void*)&&ZEND_IN_ARRAY_SPEC_CV_CONST_LABEL,
56104 (void*)&&ZEND_COUNT_SPEC_CONST_UNUSED_LABEL,
56105 (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
56106 (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
56107 (void*)&&ZEND_NULL_LABEL,
56108 (void*)&&ZEND_COUNT_SPEC_CV_UNUSED_LABEL,
56109 (void*)&&ZEND_GET_CLASS_SPEC_CONST_UNUSED_LABEL,
56110 (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
56111 (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
56112 (void*)&&ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_LABEL,
56113 (void*)&&ZEND_GET_CLASS_SPEC_CV_UNUSED_LABEL,
56114 (void*)&&ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_LABEL,
56115 (void*)&&ZEND_GET_TYPE_SPEC_CONST_UNUSED_LABEL,
56116 (void*)&&ZEND_GET_TYPE_SPEC_TMP_UNUSED_LABEL,
56117 (void*)&&ZEND_GET_TYPE_SPEC_VAR_UNUSED_LABEL,
56118 (void*)&&ZEND_NULL_LABEL,
56119 (void*)&&ZEND_GET_TYPE_SPEC_CV_UNUSED_LABEL,
56120 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_LABEL,
56121 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
56122 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
56123 (void*)&&ZEND_NULL_LABEL,
56124 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_LABEL,
56125 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
56126 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
56127 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
56128 (void*)&&ZEND_NULL_LABEL,
56129 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
56130 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
56131 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
56132 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
56133 (void*)&&ZEND_NULL_LABEL,
56134 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
56135 (void*)&&ZEND_NULL_LABEL,
56136 (void*)&&ZEND_NULL_LABEL,
56137 (void*)&&ZEND_NULL_LABEL,
56138 (void*)&&ZEND_NULL_LABEL,
56139 (void*)&&ZEND_NULL_LABEL,
56140 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_LABEL,
56141 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
56142 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
56143 (void*)&&ZEND_NULL_LABEL,
56144 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL,
56145 (void*)&&ZEND_MATCH_SPEC_CONST_CONST_LABEL,
56146 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
56147 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
56148 (void*)&&ZEND_NULL_LABEL,
56149 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_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_CASE_STRICT_SPEC_TMP_CONST_LABEL,
56156 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_TMP_LABEL,
56157 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_VAR_LABEL,
56158 (void*)&&ZEND_NULL_LABEL,
56159 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CV_LABEL,
56160 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CONST_LABEL,
56161 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_TMP_LABEL,
56162 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_VAR_LABEL,
56163 (void*)&&ZEND_NULL_LABEL,
56164 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CV_LABEL,
56165 (void*)&&ZEND_NULL_LABEL,
56166 (void*)&&ZEND_NULL_LABEL,
56167 (void*)&&ZEND_NULL_LABEL,
56168 (void*)&&ZEND_NULL_LABEL,
56169 (void*)&&ZEND_NULL_LABEL,
56170 (void*)&&ZEND_NULL_LABEL,
56171 (void*)&&ZEND_NULL_LABEL,
56172 (void*)&&ZEND_NULL_LABEL,
56173 (void*)&&ZEND_NULL_LABEL,
56174 (void*)&&ZEND_NULL_LABEL,
56175 (void*)&&ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_LABEL,
56176 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
56177 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
56178 (void*)&&ZEND_NULL_LABEL,
56179 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
56180 (void*)&&ZEND_JMP_NULL_SPEC_CONST_LABEL,
56181 (void*)&&ZEND_JMP_NULL_SPEC_TMP_LABEL,
56182 (void*)&&ZEND_JMP_NULL_SPEC_VAR_LABEL,
56183 (void*)&&ZEND_NULL_LABEL,
56184 (void*)&&ZEND_JMP_NULL_SPEC_CV_LABEL,
56185 (void*)&&ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_LABEL,
56186 (void*)&&ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_LABEL,
56187 (void*)&&ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_LABEL,
56188 (void*)&&ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_LABEL,
56189 (void*)&&ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_LABEL,
56190 (void*)&&ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_LABEL,
56191 (void*)&&ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_LABEL,
56192 (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_LABEL,
56193 (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_LABEL,
56194 (void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL,
56195 (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL,
56196 (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL,
56197 (void*)&&ZEND_NULL_LABEL,
56198 (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
56199 (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
56200 (void*)&&ZEND_NULL_LABEL,
56201 (void*)&&ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_LABEL,
56202 (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL,
56203 (void*)&&ZEND_NULL_LABEL,
56204 (void*)&&ZEND_NULL_LABEL,
56205 (void*)&&ZEND_NULL_LABEL,
56206 (void*)&&ZEND_NULL_LABEL,
56207 (void*)&&ZEND_NULL_LABEL,
56208 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56209 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56210 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56211 (void*)&&ZEND_NULL_LABEL,
56212 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56213 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56214 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56215 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56216 (void*)&&ZEND_NULL_LABEL,
56217 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56218 (void*)&&ZEND_NULL_LABEL,
56219 (void*)&&ZEND_NULL_LABEL,
56220 (void*)&&ZEND_NULL_LABEL,
56221 (void*)&&ZEND_NULL_LABEL,
56222 (void*)&&ZEND_NULL_LABEL,
56223 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56224 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56225 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56226 (void*)&&ZEND_NULL_LABEL,
56227 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56228 (void*)&&ZEND_NULL_LABEL,
56229 (void*)&&ZEND_NULL_LABEL,
56230 (void*)&&ZEND_NULL_LABEL,
56231 (void*)&&ZEND_NULL_LABEL,
56232 (void*)&&ZEND_NULL_LABEL,
56233 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
56234 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56235 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56236 (void*)&&ZEND_NULL_LABEL,
56237 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56238 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
56239 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56240 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56241 (void*)&&ZEND_NULL_LABEL,
56242 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56243 (void*)&&ZEND_NULL_LABEL,
56244 (void*)&&ZEND_NULL_LABEL,
56245 (void*)&&ZEND_NULL_LABEL,
56246 (void*)&&ZEND_NULL_LABEL,
56247 (void*)&&ZEND_NULL_LABEL,
56248 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
56249 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56250 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56251 (void*)&&ZEND_NULL_LABEL,
56252 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56253 (void*)&&ZEND_NULL_LABEL,
56254 (void*)&&ZEND_NULL_LABEL,
56255 (void*)&&ZEND_NULL_LABEL,
56256 (void*)&&ZEND_NULL_LABEL,
56257 (void*)&&ZEND_NULL_LABEL,
56258 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56259 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56260 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56261 (void*)&&ZEND_NULL_LABEL,
56262 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56263 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56264 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56265 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56266 (void*)&&ZEND_NULL_LABEL,
56267 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56268 (void*)&&ZEND_NULL_LABEL,
56269 (void*)&&ZEND_NULL_LABEL,
56270 (void*)&&ZEND_NULL_LABEL,
56271 (void*)&&ZEND_NULL_LABEL,
56272 (void*)&&ZEND_NULL_LABEL,
56273 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56274 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56275 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56276 (void*)&&ZEND_NULL_LABEL,
56277 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56278 (void*)&&ZEND_NULL_LABEL,
56279 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
56280 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
56281 (void*)&&ZEND_NULL_LABEL,
56282 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
56283 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56284 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56285 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56286 (void*)&&ZEND_NULL_LABEL,
56287 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56288 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56289 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56290 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56291 (void*)&&ZEND_NULL_LABEL,
56292 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56293 (void*)&&ZEND_NULL_LABEL,
56294 (void*)&&ZEND_NULL_LABEL,
56295 (void*)&&ZEND_NULL_LABEL,
56296 (void*)&&ZEND_NULL_LABEL,
56297 (void*)&&ZEND_NULL_LABEL,
56298 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56299 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56300 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56301 (void*)&&ZEND_NULL_LABEL,
56302 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56303 (void*)&&ZEND_NULL_LABEL,
56304 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
56305 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
56306 (void*)&&ZEND_NULL_LABEL,
56307 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
56308 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
56309 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56310 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56311 (void*)&&ZEND_NULL_LABEL,
56312 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56313 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
56314 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56315 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56316 (void*)&&ZEND_NULL_LABEL,
56317 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56318 (void*)&&ZEND_NULL_LABEL,
56319 (void*)&&ZEND_NULL_LABEL,
56320 (void*)&&ZEND_NULL_LABEL,
56321 (void*)&&ZEND_NULL_LABEL,
56322 (void*)&&ZEND_NULL_LABEL,
56323 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
56324 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56325 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56326 (void*)&&ZEND_NULL_LABEL,
56327 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56328 (void*)&&ZEND_NULL_LABEL,
56329 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56330 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56331 (void*)&&ZEND_NULL_LABEL,
56332 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56333 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56334 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56335 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56336 (void*)&&ZEND_NULL_LABEL,
56337 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56338 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56339 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56340 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56341 (void*)&&ZEND_NULL_LABEL,
56342 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56343 (void*)&&ZEND_NULL_LABEL,
56344 (void*)&&ZEND_NULL_LABEL,
56345 (void*)&&ZEND_NULL_LABEL,
56346 (void*)&&ZEND_NULL_LABEL,
56347 (void*)&&ZEND_NULL_LABEL,
56348 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56349 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56350 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56351 (void*)&&ZEND_NULL_LABEL,
56352 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56353 (void*)&&ZEND_NULL_LABEL,
56354 (void*)&&ZEND_NULL_LABEL,
56355 (void*)&&ZEND_NULL_LABEL,
56356 (void*)&&ZEND_NULL_LABEL,
56357 (void*)&&ZEND_NULL_LABEL,
56358 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56359 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56360 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56361 (void*)&&ZEND_NULL_LABEL,
56362 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56363 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56364 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56365 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56366 (void*)&&ZEND_NULL_LABEL,
56367 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56368 (void*)&&ZEND_NULL_LABEL,
56369 (void*)&&ZEND_NULL_LABEL,
56370 (void*)&&ZEND_NULL_LABEL,
56371 (void*)&&ZEND_NULL_LABEL,
56372 (void*)&&ZEND_NULL_LABEL,
56373 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56374 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56375 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56376 (void*)&&ZEND_NULL_LABEL,
56377 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56378 (void*)&&ZEND_NULL_LABEL,
56379 (void*)&&ZEND_NULL_LABEL,
56380 (void*)&&ZEND_NULL_LABEL,
56381 (void*)&&ZEND_NULL_LABEL,
56382 (void*)&&ZEND_NULL_LABEL,
56383 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56384 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56385 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56386 (void*)&&ZEND_NULL_LABEL,
56387 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56388 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56389 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56390 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56391 (void*)&&ZEND_NULL_LABEL,
56392 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56393 (void*)&&ZEND_NULL_LABEL,
56394 (void*)&&ZEND_NULL_LABEL,
56395 (void*)&&ZEND_NULL_LABEL,
56396 (void*)&&ZEND_NULL_LABEL,
56397 (void*)&&ZEND_NULL_LABEL,
56398 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56399 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56400 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56401 (void*)&&ZEND_NULL_LABEL,
56402 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56403 (void*)&&ZEND_NULL_LABEL,
56404 (void*)&&ZEND_NULL_LABEL,
56405 (void*)&&ZEND_NULL_LABEL,
56406 (void*)&&ZEND_NULL_LABEL,
56407 (void*)&&ZEND_NULL_LABEL,
56408 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56409 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56410 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56411 (void*)&&ZEND_NULL_LABEL,
56412 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56413 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56414 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56415 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56416 (void*)&&ZEND_NULL_LABEL,
56417 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_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_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56424 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56425 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56426 (void*)&&ZEND_NULL_LABEL,
56427 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56428 (void*)&&ZEND_NULL_LABEL,
56429 (void*)&&ZEND_NULL_LABEL,
56430 (void*)&&ZEND_NULL_LABEL,
56431 (void*)&&ZEND_NULL_LABEL,
56432 (void*)&&ZEND_NULL_LABEL,
56433 (void*)&&ZEND_NULL_LABEL,
56434 (void*)&&ZEND_NULL_LABEL,
56435 (void*)&&ZEND_NULL_LABEL,
56436 (void*)&&ZEND_NULL_LABEL,
56437 (void*)&&ZEND_NULL_LABEL,
56438 (void*)&&ZEND_NULL_LABEL,
56439 (void*)&&ZEND_NULL_LABEL,
56440 (void*)&&ZEND_NULL_LABEL,
56441 (void*)&&ZEND_NULL_LABEL,
56442 (void*)&&ZEND_NULL_LABEL,
56443 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56444 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56445 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56446 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56447 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56448 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56449 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56450 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56451 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56452 (void*)&&ZEND_NULL_LABEL,
56453 (void*)&&ZEND_NULL_LABEL,
56454 (void*)&&ZEND_NULL_LABEL,
56455 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56456 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56457 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56458 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56459 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56460 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56461 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56462 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56463 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56464 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56465 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56466 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56467 (void*)&&ZEND_NULL_LABEL,
56468 (void*)&&ZEND_NULL_LABEL,
56469 (void*)&&ZEND_NULL_LABEL,
56470 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56471 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56472 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56473 (void*)&&ZEND_NULL_LABEL,
56474 (void*)&&ZEND_NULL_LABEL,
56475 (void*)&&ZEND_NULL_LABEL,
56476 (void*)&&ZEND_NULL_LABEL,
56477 (void*)&&ZEND_NULL_LABEL,
56478 (void*)&&ZEND_NULL_LABEL,
56479 (void*)&&ZEND_NULL_LABEL,
56480 (void*)&&ZEND_NULL_LABEL,
56481 (void*)&&ZEND_NULL_LABEL,
56482 (void*)&&ZEND_NULL_LABEL,
56483 (void*)&&ZEND_NULL_LABEL,
56484 (void*)&&ZEND_NULL_LABEL,
56485 (void*)&&ZEND_NULL_LABEL,
56486 (void*)&&ZEND_NULL_LABEL,
56487 (void*)&&ZEND_NULL_LABEL,
56488 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56489 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56490 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56491 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56492 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56493 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56494 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56495 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56496 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56497 (void*)&&ZEND_NULL_LABEL,
56498 (void*)&&ZEND_NULL_LABEL,
56499 (void*)&&ZEND_NULL_LABEL,
56500 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56501 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56502 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56503 (void*)&&ZEND_NULL_LABEL,
56504 (void*)&&ZEND_NULL_LABEL,
56505 (void*)&&ZEND_NULL_LABEL,
56506 (void*)&&ZEND_NULL_LABEL,
56507 (void*)&&ZEND_NULL_LABEL,
56508 (void*)&&ZEND_NULL_LABEL,
56509 (void*)&&ZEND_NULL_LABEL,
56510 (void*)&&ZEND_NULL_LABEL,
56511 (void*)&&ZEND_NULL_LABEL,
56512 (void*)&&ZEND_NULL_LABEL,
56513 (void*)&&ZEND_NULL_LABEL,
56514 (void*)&&ZEND_NULL_LABEL,
56515 (void*)&&ZEND_NULL_LABEL,
56516 (void*)&&ZEND_NULL_LABEL,
56517 (void*)&&ZEND_NULL_LABEL,
56518 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56519 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56520 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56521 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56522 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56523 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56524 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56525 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56526 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56527 (void*)&&ZEND_NULL_LABEL,
56528 (void*)&&ZEND_NULL_LABEL,
56529 (void*)&&ZEND_NULL_LABEL,
56530 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56531 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56532 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56533 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56534 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56535 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56536 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56537 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56538 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56539 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56540 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56541 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56542 (void*)&&ZEND_NULL_LABEL,
56543 (void*)&&ZEND_NULL_LABEL,
56544 (void*)&&ZEND_NULL_LABEL,
56545 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56546 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56547 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56548 (void*)&&ZEND_NULL_LABEL,
56549 (void*)&&ZEND_NULL_LABEL,
56550 (void*)&&ZEND_NULL_LABEL,
56551 (void*)&&ZEND_NULL_LABEL,
56552 (void*)&&ZEND_NULL_LABEL,
56553 (void*)&&ZEND_NULL_LABEL,
56554 (void*)&&ZEND_NULL_LABEL,
56555 (void*)&&ZEND_NULL_LABEL,
56556 (void*)&&ZEND_NULL_LABEL,
56557 (void*)&&ZEND_NULL_LABEL,
56558 (void*)&&ZEND_NULL_LABEL,
56559 (void*)&&ZEND_NULL_LABEL,
56560 (void*)&&ZEND_NULL_LABEL,
56561 (void*)&&ZEND_NULL_LABEL,
56562 (void*)&&ZEND_NULL_LABEL,
56563 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56564 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56565 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56566 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56567 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56568 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56569 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56570 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56571 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56572 (void*)&&ZEND_NULL_LABEL,
56573 (void*)&&ZEND_NULL_LABEL,
56574 (void*)&&ZEND_NULL_LABEL,
56575 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56576 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56577 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56578 (void*)&&ZEND_NULL_LABEL,
56579 (void*)&&ZEND_NULL_LABEL,
56580 (void*)&&ZEND_NULL_LABEL,
56581 (void*)&&ZEND_NULL_LABEL,
56582 (void*)&&ZEND_NULL_LABEL,
56583 (void*)&&ZEND_NULL_LABEL,
56584 (void*)&&ZEND_NULL_LABEL,
56585 (void*)&&ZEND_NULL_LABEL,
56586 (void*)&&ZEND_NULL_LABEL,
56587 (void*)&&ZEND_NULL_LABEL,
56588 (void*)&&ZEND_NULL_LABEL,
56589 (void*)&&ZEND_NULL_LABEL,
56590 (void*)&&ZEND_NULL_LABEL,
56591 (void*)&&ZEND_NULL_LABEL,
56592 (void*)&&ZEND_NULL_LABEL,
56593 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56594 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56595 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56596 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56597 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56598 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56599 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56600 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56601 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56602 (void*)&&ZEND_NULL_LABEL,
56603 (void*)&&ZEND_NULL_LABEL,
56604 (void*)&&ZEND_NULL_LABEL,
56605 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56606 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56607 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56608 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56609 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56610 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56611 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56612 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56613 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56614 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56615 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56616 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56617 (void*)&&ZEND_NULL_LABEL,
56618 (void*)&&ZEND_NULL_LABEL,
56619 (void*)&&ZEND_NULL_LABEL,
56620 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56621 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56622 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56623 (void*)&&ZEND_NULL_LABEL,
56624 (void*)&&ZEND_NULL_LABEL,
56625 (void*)&&ZEND_NULL_LABEL,
56626 (void*)&&ZEND_NULL_LABEL,
56627 (void*)&&ZEND_NULL_LABEL,
56628 (void*)&&ZEND_NULL_LABEL,
56629 (void*)&&ZEND_NULL_LABEL,
56630 (void*)&&ZEND_NULL_LABEL,
56631 (void*)&&ZEND_NULL_LABEL,
56632 (void*)&&ZEND_NULL_LABEL,
56633 (void*)&&ZEND_NULL_LABEL,
56634 (void*)&&ZEND_NULL_LABEL,
56635 (void*)&&ZEND_NULL_LABEL,
56636 (void*)&&ZEND_NULL_LABEL,
56637 (void*)&&ZEND_NULL_LABEL,
56638 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56639 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56640 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56641 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56642 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56643 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56644 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56645 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56646 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56647 (void*)&&ZEND_NULL_LABEL,
56648 (void*)&&ZEND_NULL_LABEL,
56649 (void*)&&ZEND_NULL_LABEL,
56650 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56651 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56652 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56653 (void*)&&ZEND_NULL_LABEL,
56654 (void*)&&ZEND_NULL_LABEL,
56655 (void*)&&ZEND_NULL_LABEL,
56656 (void*)&&ZEND_NULL_LABEL,
56657 (void*)&&ZEND_NULL_LABEL,
56658 (void*)&&ZEND_NULL_LABEL,
56659 (void*)&&ZEND_NULL_LABEL,
56660 (void*)&&ZEND_NULL_LABEL,
56661 (void*)&&ZEND_NULL_LABEL,
56662 (void*)&&ZEND_NULL_LABEL,
56663 (void*)&&ZEND_NULL_LABEL,
56664 (void*)&&ZEND_NULL_LABEL,
56665 (void*)&&ZEND_NULL_LABEL,
56666 (void*)&&ZEND_NULL_LABEL,
56667 (void*)&&ZEND_NULL_LABEL,
56668 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56669 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56670 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56671 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56672 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56673 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56674 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56675 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56676 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56677 (void*)&&ZEND_NULL_LABEL,
56678 (void*)&&ZEND_NULL_LABEL,
56679 (void*)&&ZEND_NULL_LABEL,
56680 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56681 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56682 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56683 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56684 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56685 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56686 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56687 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56688 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56689 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56690 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56691 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56692 (void*)&&ZEND_NULL_LABEL,
56693 (void*)&&ZEND_NULL_LABEL,
56694 (void*)&&ZEND_NULL_LABEL,
56695 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56696 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56697 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56698 (void*)&&ZEND_NULL_LABEL,
56699 (void*)&&ZEND_NULL_LABEL,
56700 (void*)&&ZEND_NULL_LABEL,
56701 (void*)&&ZEND_NULL_LABEL,
56702 (void*)&&ZEND_NULL_LABEL,
56703 (void*)&&ZEND_NULL_LABEL,
56704 (void*)&&ZEND_NULL_LABEL,
56705 (void*)&&ZEND_NULL_LABEL,
56706 (void*)&&ZEND_NULL_LABEL,
56707 (void*)&&ZEND_NULL_LABEL,
56708 (void*)&&ZEND_NULL_LABEL,
56709 (void*)&&ZEND_NULL_LABEL,
56710 (void*)&&ZEND_NULL_LABEL,
56711 (void*)&&ZEND_NULL_LABEL,
56712 (void*)&&ZEND_NULL_LABEL,
56713 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56714 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56715 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56716 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56717 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56718 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56719 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56720 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56721 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56722 (void*)&&ZEND_NULL_LABEL,
56723 (void*)&&ZEND_NULL_LABEL,
56724 (void*)&&ZEND_NULL_LABEL,
56725 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56726 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56727 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56728 (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
56729 (void*)&&ZEND_NULL_LABEL,
56730 (void*)&&ZEND_NULL_LABEL,
56731 (void*)&&ZEND_NULL_LABEL,
56732 (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
56733 (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
56734 (void*)&&ZEND_NULL_LABEL,
56735 (void*)&&ZEND_NULL_LABEL,
56736 (void*)&&ZEND_NULL_LABEL,
56737 (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
56738 (void*)&&ZEND_NULL_LABEL,
56739 (void*)&&ZEND_NULL_LABEL,
56740 (void*)&&ZEND_NULL_LABEL,
56741 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
56742 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56743 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56744 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
56745 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56746 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56747 (void*)&&ZEND_NULL_LABEL,
56748 (void*)&&ZEND_NULL_LABEL,
56749 (void*)&&ZEND_NULL_LABEL,
56750 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
56751 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56752 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56753 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
56754 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56755 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56756 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56757 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56758 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56759 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56760 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56761 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56762 (void*)&&ZEND_NULL_LABEL,
56763 (void*)&&ZEND_NULL_LABEL,
56764 (void*)&&ZEND_NULL_LABEL,
56765 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56766 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56767 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56768 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
56769 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56770 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56771 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56772 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56773 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56774 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56775 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56776 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56777 (void*)&&ZEND_NULL_LABEL,
56778 (void*)&&ZEND_NULL_LABEL,
56779 (void*)&&ZEND_NULL_LABEL,
56780 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56781 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56782 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56783 (void*)&&ZEND_NULL_LABEL,
56784 (void*)&&ZEND_NULL_LABEL,
56785 (void*)&&ZEND_NULL_LABEL,
56786 (void*)&&ZEND_NULL_LABEL,
56787 (void*)&&ZEND_NULL_LABEL,
56788 (void*)&&ZEND_NULL_LABEL,
56789 (void*)&&ZEND_NULL_LABEL,
56790 (void*)&&ZEND_NULL_LABEL,
56791 (void*)&&ZEND_NULL_LABEL,
56792 (void*)&&ZEND_NULL_LABEL,
56793 (void*)&&ZEND_NULL_LABEL,
56794 (void*)&&ZEND_NULL_LABEL,
56795 (void*)&&ZEND_NULL_LABEL,
56796 (void*)&&ZEND_NULL_LABEL,
56797 (void*)&&ZEND_NULL_LABEL,
56798 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
56799 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56800 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56801 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56802 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56803 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56804 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56805 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56806 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56807 (void*)&&ZEND_NULL_LABEL,
56808 (void*)&&ZEND_NULL_LABEL,
56809 (void*)&&ZEND_NULL_LABEL,
56810 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56811 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56812 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56813 (void*)&&ZEND_NULL_LABEL,
56814 (void*)&&ZEND_NULL_LABEL,
56815 (void*)&&ZEND_NULL_LABEL,
56816 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56817 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56818 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56819 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56820 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56821 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56822 (void*)&&ZEND_NULL_LABEL,
56823 (void*)&&ZEND_NULL_LABEL,
56824 (void*)&&ZEND_NULL_LABEL,
56825 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56826 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56827 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56828 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56829 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56830 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56831 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56832 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56833 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56834 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56835 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56836 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56837 (void*)&&ZEND_NULL_LABEL,
56838 (void*)&&ZEND_NULL_LABEL,
56839 (void*)&&ZEND_NULL_LABEL,
56840 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56841 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56842 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56843 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56844 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56845 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56846 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56847 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56848 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56849 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56850 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56851 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56852 (void*)&&ZEND_NULL_LABEL,
56853 (void*)&&ZEND_NULL_LABEL,
56854 (void*)&&ZEND_NULL_LABEL,
56855 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56856 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56857 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56858 (void*)&&ZEND_NULL_LABEL,
56859 (void*)&&ZEND_NULL_LABEL,
56860 (void*)&&ZEND_NULL_LABEL,
56861 (void*)&&ZEND_NULL_LABEL,
56862 (void*)&&ZEND_NULL_LABEL,
56863 (void*)&&ZEND_NULL_LABEL,
56864 (void*)&&ZEND_NULL_LABEL,
56865 (void*)&&ZEND_NULL_LABEL,
56866 (void*)&&ZEND_NULL_LABEL,
56867 (void*)&&ZEND_NULL_LABEL,
56868 (void*)&&ZEND_NULL_LABEL,
56869 (void*)&&ZEND_NULL_LABEL,
56870 (void*)&&ZEND_NULL_LABEL,
56871 (void*)&&ZEND_NULL_LABEL,
56872 (void*)&&ZEND_NULL_LABEL,
56873 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56874 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56875 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56876 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56877 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56878 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56879 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56880 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56881 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56882 (void*)&&ZEND_NULL_LABEL,
56883 (void*)&&ZEND_NULL_LABEL,
56884 (void*)&&ZEND_NULL_LABEL,
56885 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56886 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56887 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56888 (void*)&&ZEND_NULL_LABEL,
56889 (void*)&&ZEND_NULL_LABEL,
56890 (void*)&&ZEND_NULL_LABEL,
56891 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
56892 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56893 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56894 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
56895 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56896 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56897 (void*)&&ZEND_NULL_LABEL,
56898 (void*)&&ZEND_NULL_LABEL,
56899 (void*)&&ZEND_NULL_LABEL,
56900 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
56901 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56902 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56903 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56904 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56905 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56906 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56907 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56908 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56909 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56910 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56911 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56912 (void*)&&ZEND_NULL_LABEL,
56913 (void*)&&ZEND_NULL_LABEL,
56914 (void*)&&ZEND_NULL_LABEL,
56915 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56916 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56917 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56918 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56919 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56920 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56921 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56922 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56923 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56924 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56925 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56926 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56927 (void*)&&ZEND_NULL_LABEL,
56928 (void*)&&ZEND_NULL_LABEL,
56929 (void*)&&ZEND_NULL_LABEL,
56930 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56931 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56932 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56933 (void*)&&ZEND_NULL_LABEL,
56934 (void*)&&ZEND_NULL_LABEL,
56935 (void*)&&ZEND_NULL_LABEL,
56936 (void*)&&ZEND_NULL_LABEL,
56937 (void*)&&ZEND_NULL_LABEL,
56938 (void*)&&ZEND_NULL_LABEL,
56939 (void*)&&ZEND_NULL_LABEL,
56940 (void*)&&ZEND_NULL_LABEL,
56941 (void*)&&ZEND_NULL_LABEL,
56942 (void*)&&ZEND_NULL_LABEL,
56943 (void*)&&ZEND_NULL_LABEL,
56944 (void*)&&ZEND_NULL_LABEL,
56945 (void*)&&ZEND_NULL_LABEL,
56946 (void*)&&ZEND_NULL_LABEL,
56947 (void*)&&ZEND_NULL_LABEL,
56948 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56949 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56950 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56951 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56952 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56953 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56954 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56955 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56956 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56957 (void*)&&ZEND_NULL_LABEL,
56958 (void*)&&ZEND_NULL_LABEL,
56959 (void*)&&ZEND_NULL_LABEL,
56960 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56961 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56962 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56963 (void*)&&ZEND_NULL_LABEL,
56964 (void*)&&ZEND_NULL_LABEL,
56965 (void*)&&ZEND_NULL_LABEL,
56966 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56967 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56968 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56969 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56970 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56971 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56972 (void*)&&ZEND_NULL_LABEL,
56973 (void*)&&ZEND_NULL_LABEL,
56974 (void*)&&ZEND_NULL_LABEL,
56975 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56976 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56977 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56978 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56979 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56980 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56981 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56982 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56983 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56984 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56985 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56986 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56987 (void*)&&ZEND_NULL_LABEL,
56988 (void*)&&ZEND_NULL_LABEL,
56989 (void*)&&ZEND_NULL_LABEL,
56990 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56991 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56992 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56993 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56994 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56995 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56996 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56997 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56998 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56999 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57000 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57001 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57002 (void*)&&ZEND_NULL_LABEL,
57003 (void*)&&ZEND_NULL_LABEL,
57004 (void*)&&ZEND_NULL_LABEL,
57005 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57006 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57007 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57008 (void*)&&ZEND_NULL_LABEL,
57009 (void*)&&ZEND_NULL_LABEL,
57010 (void*)&&ZEND_NULL_LABEL,
57011 (void*)&&ZEND_NULL_LABEL,
57012 (void*)&&ZEND_NULL_LABEL,
57013 (void*)&&ZEND_NULL_LABEL,
57014 (void*)&&ZEND_NULL_LABEL,
57015 (void*)&&ZEND_NULL_LABEL,
57016 (void*)&&ZEND_NULL_LABEL,
57017 (void*)&&ZEND_NULL_LABEL,
57018 (void*)&&ZEND_NULL_LABEL,
57019 (void*)&&ZEND_NULL_LABEL,
57020 (void*)&&ZEND_NULL_LABEL,
57021 (void*)&&ZEND_NULL_LABEL,
57022 (void*)&&ZEND_NULL_LABEL,
57023 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57024 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57025 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57026 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57027 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57028 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57029 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57030 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57031 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57032 (void*)&&ZEND_NULL_LABEL,
57033 (void*)&&ZEND_NULL_LABEL,
57034 (void*)&&ZEND_NULL_LABEL,
57035 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57036 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57037 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57038 (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
57039 (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
57040 (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
57041 (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_LABEL,
57042 (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
57043 (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
57044 (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
57045 (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_LABEL,
57046 (void*)&&ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
57047 (void*)&&ZEND_POST_INC_LONG_SPEC_CV_LABEL,
57048 (void*)&&ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
57049 (void*)&&ZEND_POST_DEC_LONG_SPEC_CV_LABEL,
57050 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_CONST_LABEL,
57051 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
57052 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
57053 (void*)&&ZEND_NULL_LABEL,
57054 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
57055 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_LABEL,
57056 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
57057 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
57058 (void*)&&ZEND_NULL_LABEL,
57059 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
57060 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_CONST_LABEL,
57061 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
57062 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
57063 (void*)&&ZEND_NULL_LABEL,
57064 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
57065 (void*)&&ZEND_NULL_LABEL,
57066 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
57067 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
57068 (void*)&&ZEND_NULL_LABEL,
57069 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
57070 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
57071 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57072 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57073 (void*)&&ZEND_NULL_LABEL,
57074 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57075 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
57076 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57077 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57078 (void*)&&ZEND_NULL_LABEL,
57079 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57080 (void*)&&ZEND_NULL_LABEL,
57081 (void*)&&ZEND_NULL_LABEL,
57082 (void*)&&ZEND_NULL_LABEL,
57083 (void*)&&ZEND_NULL_LABEL,
57084 (void*)&&ZEND_NULL_LABEL,
57085 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_LABEL,
57086 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
57087 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
57088 (void*)&&ZEND_NULL_LABEL,
57089 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
57090 (void*)&&ZEND_NULL_LABEL,
57091 (void*)&&ZEND_NULL_LABEL,
57092 (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_VAR_LABEL,
57093 (void*)&&ZEND_NULL_LABEL,
57094 (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_CV_LABEL,
57095 (void*)&&ZEND_NULL_LABEL,
57096 (void*)&&ZEND_NULL_LABEL,
57097 (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_LABEL,
57098 (void*)&&ZEND_NULL_LABEL,
57099 (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_LABEL,
57100 (void*)&&ZEND_SEND_VAL_SIMPLE_SPEC_CONST_LABEL,
57101 (void*)&&ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_LABEL,
57102 (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
57103 (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_LABEL,
57104 (void*)&&ZEND_NULL_LABEL
57105 };
57106 zend_opcode_handlers = (const void **) labels;
57107 zend_handlers_count = sizeof(labels) / sizeof(void*);
57108 memset(&hybrid_halt_op, 0, sizeof(hybrid_halt_op));
57109 hybrid_halt_op.handler = (void*)&&HYBRID_HALT_LABEL;
57110 #ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
57111 memset(vm_stack_data.hybrid_jit_red_zone, 0, ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE);
57112 #endif
57113 if (zend_touch_vm_stack_data) {
57114 zend_touch_vm_stack_data(&vm_stack_data);
57115 }
57116 goto HYBRID_HALT_LABEL;
57117 }
57118 #endif
57119
57120 LOAD_OPLINE();
57121 ZEND_VM_LOOP_INTERRUPT_CHECK();
57122
57123 #ifdef ZEND_CHECK_STACK_LIMIT
57124 if (UNEXPECTED(zend_call_stack_overflowed(EG(stack_limit)))) {
57125 zend_call_stack_size_error();
57126 /* No opline was executed before exception */
57127 EG(opline_before_exception) = NULL;
57128 LOAD_OPLINE();
57129 /* Fall through to handle exception below. */
57130 }
57131 #endif /* ZEND_CHECK_STACK_LIMIT */
57132
57133 while (1) {
57134 #if !defined(ZEND_VM_FP_GLOBAL_REG) || !defined(ZEND_VM_IP_GLOBAL_REG)
57135 int ret;
57136 #endif
57137 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
57138 HYBRID_SWITCH() {
57139 #else
57140 #if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
57141 ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57142 if (UNEXPECTED(!OPLINE)) {
57143 #else
57144 if (UNEXPECTED((ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)) != 0)) {
57145 #endif
57146 #endif
57147 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
57148 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC):
57149 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
57150 ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57151 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
57152 HYBRID_BREAK();
57153 HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC):
57154 VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC)
57155 ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57156 VM_TRACE_OP_END(ZEND_PRE_INC_STATIC_PROP_SPEC)
57157 HYBRID_BREAK();
57158 HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC):
57159 VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC)
57160 ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57161 VM_TRACE_OP_END(ZEND_POST_INC_STATIC_PROP_SPEC)
57162 HYBRID_BREAK();
57163 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC):
57164 VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC)
57165 ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57166 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_R_SPEC)
57167 HYBRID_BREAK();
57168 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_W_SPEC):
57169 VM_TRACE(ZEND_FETCH_STATIC_PROP_W_SPEC)
57170 ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57171 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_W_SPEC)
57172 HYBRID_BREAK();
57173 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_RW_SPEC):
57174 VM_TRACE(ZEND_FETCH_STATIC_PROP_RW_SPEC)
57175 ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57176 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_RW_SPEC)
57177 HYBRID_BREAK();
57178 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC):
57179 VM_TRACE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
57180 ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57181 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
57182 HYBRID_BREAK();
57183 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC):
57184 VM_TRACE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
57185 ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57186 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
57187 HYBRID_BREAK();
57188 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_IS_SPEC):
57189 VM_TRACE(ZEND_FETCH_STATIC_PROP_IS_SPEC)
57190 ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57191 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_IS_SPEC)
57192 HYBRID_BREAK();
57193 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST):
57194 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
57195 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57196 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
57197 HYBRID_BREAK();
57198 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP):
57199 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
57200 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57201 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
57202 HYBRID_BREAK();
57203 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR):
57204 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
57205 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57206 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
57207 HYBRID_BREAK();
57208 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV):
57209 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
57210 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57211 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
57212 HYBRID_BREAK();
57213 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC):
57214 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
57215 ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57216 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
57217 HYBRID_BREAK();
57218 zend_leave_helper_SPEC_LABEL:
57219 {
57220 zend_execute_data *old_execute_data;
57221 uint32_t call_info = EX_CALL_INFO();
57222 SAVE_OPLINE();
57223
57224 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)) {
57225 EG(current_execute_data) = EX(prev_execute_data);
57226 i_free_compiled_variables(execute_data);
57227
57228 #ifdef ZEND_PREFER_RELOAD
57229 call_info = EX_CALL_INFO();
57230 #endif
57231 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
57232 OBJ_RELEASE(Z_OBJ(execute_data->This));
57233 } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
57234 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
57235 }
57236 EG(vm_stack_top) = (zval*)execute_data;
57237 execute_data = EX(prev_execute_data);
57238
57239 if (UNEXPECTED(EG(exception) != NULL)) {
57240 zend_rethrow_exception(execute_data);
57241 HANDLE_EXCEPTION_LEAVE();
57242 }
57243
57244 LOAD_NEXT_OPLINE();
57245 ZEND_VM_LEAVE();
57246 } else if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP)) == 0)) {
57247 EG(current_execute_data) = EX(prev_execute_data);
57248 i_free_compiled_variables(execute_data);
57249
57250 #ifdef ZEND_PREFER_RELOAD
57251 call_info = EX_CALL_INFO();
57252 #endif
57253 if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
57254 zend_clean_and_cache_symbol_table(EX(symbol_table));
57255 }
57256
57257 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
57258 zend_free_extra_named_params(EX(extra_named_params));
57259 }
57260
57261 /* Free extra args before releasing the closure,
57262 * as that may free the op_array. */
57263 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
57264
57265 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
57266 OBJ_RELEASE(Z_OBJ(execute_data->This));
57267 } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
57268 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
57269 }
57270
57271 old_execute_data = execute_data;
57272 execute_data = EX(prev_execute_data);
57273 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
57274
57275 if (UNEXPECTED(EG(exception) != NULL)) {
57276 zend_rethrow_exception(execute_data);
57277 HANDLE_EXCEPTION_LEAVE();
57278 }
57279
57280 LOAD_NEXT_OPLINE();
57281 ZEND_VM_LEAVE();
57282 } else if (EXPECTED((call_info & ZEND_CALL_TOP) == 0)) {
57283 if (EX(func)->op_array.last_var > 0) {
57284 zend_detach_symbol_table(execute_data);
57285 call_info |= ZEND_CALL_NEEDS_REATTACH;
57286 }
57287 zend_destroy_static_vars(&EX(func)->op_array);
57288 destroy_op_array(&EX(func)->op_array);
57289 efree_size(EX(func), sizeof(zend_op_array));
57290 old_execute_data = execute_data;
57291 execute_data = EG(current_execute_data) = EX(prev_execute_data);
57292 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
57293
57294 if (call_info & ZEND_CALL_NEEDS_REATTACH) {
57295 if (EX(func)->op_array.last_var > 0) {
57296 zend_attach_symbol_table(execute_data);
57297 } else {
57298 ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_NEEDS_REATTACH);
57299 }
57300 }
57301 if (UNEXPECTED(EG(exception) != NULL)) {
57302 zend_rethrow_exception(execute_data);
57303 HANDLE_EXCEPTION_LEAVE();
57304 }
57305
57306 LOAD_NEXT_OPLINE();
57307 ZEND_VM_LEAVE();
57308 } else {
57309 if (EXPECTED((call_info & ZEND_CALL_CODE) == 0)) {
57310 EG(current_execute_data) = EX(prev_execute_data);
57311 i_free_compiled_variables(execute_data);
57312 #ifdef ZEND_PREFER_RELOAD
57313 call_info = EX_CALL_INFO();
57314 #endif
57315 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) {
57316 if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
57317 zend_clean_and_cache_symbol_table(EX(symbol_table));
57318 }
57319 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
57320 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
57321 zend_free_extra_named_params(EX(extra_named_params));
57322 }
57323 }
57324 if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
57325 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
57326 }
57327 ZEND_VM_RETURN();
57328 } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
57329 zend_array *symbol_table = EX(symbol_table);
57330
57331 if (EX(func)->op_array.last_var > 0) {
57332 zend_detach_symbol_table(execute_data);
57333 call_info |= ZEND_CALL_NEEDS_REATTACH;
57334 }
57335 if (call_info & ZEND_CALL_NEEDS_REATTACH) {
57336 old_execute_data = EX(prev_execute_data);
57337 while (old_execute_data) {
57338 if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
57339 if (old_execute_data->symbol_table == symbol_table) {
57340 if (old_execute_data->func->op_array.last_var > 0) {
57341 zend_attach_symbol_table(old_execute_data);
57342 } else {
57343 ZEND_ADD_CALL_FLAG(old_execute_data, ZEND_CALL_NEEDS_REATTACH);
57344 }
57345 }
57346 break;
57347 }
57348 old_execute_data = old_execute_data->prev_execute_data;
57349 }
57350 }
57351 EG(current_execute_data) = EX(prev_execute_data);
57352 ZEND_VM_RETURN();
57353 }
57354 }
57355 }
57356
57357 HYBRID_CASE(ZEND_JMP_SPEC):
57358 VM_TRACE(ZEND_JMP_SPEC)
57359 ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57360 VM_TRACE_OP_END(ZEND_JMP_SPEC)
57361 HYBRID_BREAK();
57362 HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED):
57363 VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
57364 ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57365 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
57366 HYBRID_BREAK();
57367 HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_USED):
57368 VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_USED)
57369 ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57370 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_USED)
57371 HYBRID_BREAK();
57372 HYBRID_CASE(ZEND_DO_ICALL_SPEC_OBSERVER):
57373 VM_TRACE(ZEND_DO_ICALL_SPEC_OBSERVER)
57374 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57375 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_OBSERVER)
57376 HYBRID_BREAK();
57377 HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED):
57378 VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
57379 ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57380 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
57381 HYBRID_BREAK();
57382 HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_USED):
57383 VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_USED)
57384 ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57385 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_USED)
57386 HYBRID_BREAK();
57387 HYBRID_CASE(ZEND_DO_UCALL_SPEC_OBSERVER):
57388 VM_TRACE(ZEND_DO_UCALL_SPEC_OBSERVER)
57389 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57390 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_OBSERVER)
57391 HYBRID_BREAK();
57392 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED):
57393 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
57394 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57395 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
57396 HYBRID_BREAK();
57397 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED):
57398 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
57399 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57400 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
57401 HYBRID_BREAK();
57402 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER):
57403 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
57404 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57405 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
57406 HYBRID_BREAK();
57407 HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED):
57408 VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
57409 ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57410 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
57411 HYBRID_BREAK();
57412 HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_USED):
57413 VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_USED)
57414 ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57415 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_USED)
57416 HYBRID_BREAK();
57417 HYBRID_CASE(ZEND_DO_FCALL_SPEC_OBSERVER):
57418 VM_TRACE(ZEND_DO_FCALL_SPEC_OBSERVER)
57419 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57420 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_OBSERVER)
57421 HYBRID_BREAK();
57422 HYBRID_CASE(ZEND_GENERATOR_CREATE_SPEC):
57423 VM_TRACE(ZEND_GENERATOR_CREATE_SPEC)
57424 ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57425 VM_TRACE_OP_END(ZEND_GENERATOR_CREATE_SPEC)
57426 HYBRID_BREAK();
57427 HYBRID_CASE(ZEND_SEND_UNPACK_SPEC):
57428 VM_TRACE(ZEND_SEND_UNPACK_SPEC)
57429 ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57430 VM_TRACE_OP_END(ZEND_SEND_UNPACK_SPEC)
57431 HYBRID_BREAK();
57432 HYBRID_CASE(ZEND_SEND_ARRAY_SPEC):
57433 VM_TRACE(ZEND_SEND_ARRAY_SPEC)
57434 ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57435 VM_TRACE_OP_END(ZEND_SEND_ARRAY_SPEC)
57436 HYBRID_BREAK();
57437 HYBRID_CASE(ZEND_RECV_NOTYPE_SPEC):
57438 VM_TRACE(ZEND_RECV_NOTYPE_SPEC)
57439 ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57440 VM_TRACE_OP_END(ZEND_RECV_NOTYPE_SPEC)
57441 HYBRID_BREAK();
57442 HYBRID_CASE(ZEND_ADD_ARRAY_UNPACK_SPEC):
57443 VM_TRACE(ZEND_ADD_ARRAY_UNPACK_SPEC)
57444 ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57445 VM_TRACE_OP_END(ZEND_ADD_ARRAY_UNPACK_SPEC)
57446 HYBRID_BREAK();
57447 HYBRID_CASE(ZEND_UNSET_STATIC_PROP_SPEC):
57448 VM_TRACE(ZEND_UNSET_STATIC_PROP_SPEC)
57449 ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57450 VM_TRACE_OP_END(ZEND_UNSET_STATIC_PROP_SPEC)
57451 HYBRID_BREAK();
57452 HYBRID_CASE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC):
57453 VM_TRACE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
57454 ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57455 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
57456 HYBRID_BREAK();
57457 HYBRID_CASE(ZEND_EXIT_SPEC):
57458 VM_TRACE(ZEND_EXIT_SPEC)
57459 ZEND_EXIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57460 VM_TRACE_OP_END(ZEND_EXIT_SPEC)
57461 HYBRID_BREAK();
57462 HYBRID_CASE(ZEND_BEGIN_SILENCE_SPEC):
57463 VM_TRACE(ZEND_BEGIN_SILENCE_SPEC)
57464 ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57465 VM_TRACE_OP_END(ZEND_BEGIN_SILENCE_SPEC)
57466 HYBRID_BREAK();
57467 HYBRID_CASE(ZEND_EXT_STMT_SPEC):
57468 VM_TRACE(ZEND_EXT_STMT_SPEC)
57469 ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57470 VM_TRACE_OP_END(ZEND_EXT_STMT_SPEC)
57471 HYBRID_BREAK();
57472 HYBRID_CASE(ZEND_EXT_FCALL_BEGIN_SPEC):
57473 VM_TRACE(ZEND_EXT_FCALL_BEGIN_SPEC)
57474 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57475 VM_TRACE_OP_END(ZEND_EXT_FCALL_BEGIN_SPEC)
57476 HYBRID_BREAK();
57477 HYBRID_CASE(ZEND_EXT_FCALL_END_SPEC):
57478 VM_TRACE(ZEND_EXT_FCALL_END_SPEC)
57479 ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57480 VM_TRACE_OP_END(ZEND_EXT_FCALL_END_SPEC)
57481 HYBRID_BREAK();
57482 HYBRID_CASE(ZEND_DECLARE_ANON_CLASS_SPEC):
57483 VM_TRACE(ZEND_DECLARE_ANON_CLASS_SPEC)
57484 ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57485 VM_TRACE_OP_END(ZEND_DECLARE_ANON_CLASS_SPEC)
57486 HYBRID_BREAK();
57487 HYBRID_CASE(ZEND_DECLARE_FUNCTION_SPEC):
57488 VM_TRACE(ZEND_DECLARE_FUNCTION_SPEC)
57489 ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57490 VM_TRACE_OP_END(ZEND_DECLARE_FUNCTION_SPEC)
57491 HYBRID_BREAK();
57492 HYBRID_CASE(ZEND_TICKS_SPEC):
57493 VM_TRACE(ZEND_TICKS_SPEC)
57494 ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57495 VM_TRACE_OP_END(ZEND_TICKS_SPEC)
57496 HYBRID_BREAK();
57497 HYBRID_CASE(ZEND_EXT_NOP_SPEC):
57498 VM_TRACE(ZEND_EXT_NOP_SPEC)
57499 ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57500 VM_TRACE_OP_END(ZEND_EXT_NOP_SPEC)
57501 HYBRID_BREAK();
57502 HYBRID_CASE(ZEND_NOP_SPEC):
57503 VM_TRACE(ZEND_NOP_SPEC)
57504 ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57505 VM_TRACE_OP_END(ZEND_NOP_SPEC)
57506 HYBRID_BREAK();
57507 HYBRID_CASE(ZEND_HANDLE_EXCEPTION_SPEC):
57508 VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC)
57509 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57510 VM_TRACE_OP_END(ZEND_HANDLE_EXCEPTION_SPEC)
57511 HYBRID_BREAK();
57512 HYBRID_CASE(ZEND_USER_OPCODE_SPEC):
57513 VM_TRACE(ZEND_USER_OPCODE_SPEC)
57514 ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57515 VM_TRACE_OP_END(ZEND_USER_OPCODE_SPEC)
57516 HYBRID_BREAK();
57517 HYBRID_CASE(ZEND_DISCARD_EXCEPTION_SPEC):
57518 VM_TRACE(ZEND_DISCARD_EXCEPTION_SPEC)
57519 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57520 VM_TRACE_OP_END(ZEND_DISCARD_EXCEPTION_SPEC)
57521 HYBRID_BREAK();
57522 HYBRID_CASE(ZEND_FAST_CALL_SPEC):
57523 VM_TRACE(ZEND_FAST_CALL_SPEC)
57524 ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57525 VM_TRACE_OP_END(ZEND_FAST_CALL_SPEC)
57526 HYBRID_BREAK();
57527 HYBRID_CASE(ZEND_FAST_RET_SPEC):
57528 VM_TRACE(ZEND_FAST_RET_SPEC)
57529 ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57530 VM_TRACE_OP_END(ZEND_FAST_RET_SPEC)
57531 HYBRID_BREAK();
57532 HYBRID_CASE(ZEND_ASSERT_CHECK_SPEC):
57533 VM_TRACE(ZEND_ASSERT_CHECK_SPEC)
57534 ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57535 VM_TRACE_OP_END(ZEND_ASSERT_CHECK_SPEC)
57536 HYBRID_BREAK();
57537 HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC):
57538 VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC)
57539 ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57540 VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC)
57541 HYBRID_BREAK();
57542 HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER):
57543 VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
57544 ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57545 VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
57546 HYBRID_BREAK();
57547 HYBRID_CASE(ZEND_FRAMELESS_ICALL_2_SPEC):
57548 VM_TRACE(ZEND_FRAMELESS_ICALL_2_SPEC)
57549 ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57550 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_2_SPEC)
57551 HYBRID_BREAK();
57552 HYBRID_CASE(ZEND_FRAMELESS_ICALL_3_SPEC):
57553 VM_TRACE(ZEND_FRAMELESS_ICALL_3_SPEC)
57554 ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57555 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_3_SPEC)
57556 HYBRID_BREAK();
57557 HYBRID_CASE(ZEND_JMP_FORWARD_SPEC):
57558 VM_TRACE(ZEND_JMP_FORWARD_SPEC)
57559 ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57560 VM_TRACE_OP_END(ZEND_JMP_FORWARD_SPEC)
57561 HYBRID_BREAK();
57562 HYBRID_CASE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST):
57563 VM_TRACE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
57564 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57565 VM_TRACE_OP_END(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
57566 HYBRID_BREAK();
57567 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST):
57568 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
57569 ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57570 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
57571 HYBRID_BREAK();
57572 HYBRID_CASE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST):
57573 VM_TRACE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
57574 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57575 VM_TRACE_OP_END(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
57576 HYBRID_BREAK();
57577 HYBRID_CASE(ZEND_INIT_FCALL_SPEC_CONST):
57578 VM_TRACE(ZEND_INIT_FCALL_SPEC_CONST)
57579 ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57580 VM_TRACE_OP_END(ZEND_INIT_FCALL_SPEC_CONST)
57581 HYBRID_BREAK();
57582 HYBRID_CASE(ZEND_INIT_FCALL_OFFSET_SPEC_CONST):
57583 VM_TRACE(ZEND_INIT_FCALL_OFFSET_SPEC_CONST)
57584 ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57585 VM_TRACE_OP_END(ZEND_INIT_FCALL_OFFSET_SPEC_CONST)
57586 HYBRID_BREAK();
57587 HYBRID_CASE(ZEND_RECV_INIT_SPEC_CONST):
57588 VM_TRACE(ZEND_RECV_INIT_SPEC_CONST)
57589 ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57590 VM_TRACE_OP_END(ZEND_RECV_INIT_SPEC_CONST)
57591 HYBRID_BREAK();
57592 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR):
57593 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
57594 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57595 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
57596 HYBRID_BREAK();
57597 HYBRID_CASE(ZEND_RECV_SPEC_UNUSED):
57598 VM_TRACE(ZEND_RECV_SPEC_UNUSED)
57599 ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57600 VM_TRACE_OP_END(ZEND_RECV_SPEC_UNUSED)
57601 HYBRID_BREAK();
57602 HYBRID_CASE(ZEND_RECV_VARIADIC_SPEC_UNUSED):
57603 VM_TRACE(ZEND_RECV_VARIADIC_SPEC_UNUSED)
57604 ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57605 VM_TRACE_OP_END(ZEND_RECV_VARIADIC_SPEC_UNUSED)
57606 HYBRID_BREAK();
57607 HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED):
57608 VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
57609 ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57610 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
57611 HYBRID_BREAK();
57612 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV):
57613 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
57614 ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57615 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
57616 HYBRID_BREAK();
57617 HYBRID_CASE(ZEND_BW_NOT_SPEC_CONST):
57618 VM_TRACE(ZEND_BW_NOT_SPEC_CONST)
57619 ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57620 VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_CONST)
57621 HYBRID_BREAK();
57622 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CONST):
57623 VM_TRACE(ZEND_BOOL_NOT_SPEC_CONST)
57624 ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57625 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CONST)
57626 HYBRID_BREAK();
57627 HYBRID_CASE(ZEND_ECHO_SPEC_CONST):
57628 VM_TRACE(ZEND_ECHO_SPEC_CONST)
57629 ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57630 VM_TRACE_OP_END(ZEND_ECHO_SPEC_CONST)
57631 HYBRID_BREAK();
57632 HYBRID_CASE(ZEND_JMPZ_SPEC_CONST):
57633 VM_TRACE(ZEND_JMPZ_SPEC_CONST)
57634 ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57635 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CONST)
57636 HYBRID_BREAK();
57637 HYBRID_CASE(ZEND_JMPNZ_SPEC_CONST):
57638 VM_TRACE(ZEND_JMPNZ_SPEC_CONST)
57639 ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57640 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CONST)
57641 HYBRID_BREAK();
57642 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CONST):
57643 VM_TRACE(ZEND_JMPZ_EX_SPEC_CONST)
57644 ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57645 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CONST)
57646 HYBRID_BREAK();
57647 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CONST):
57648 VM_TRACE(ZEND_JMPNZ_EX_SPEC_CONST)
57649 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57650 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CONST)
57651 HYBRID_BREAK();
57652 HYBRID_CASE(ZEND_RETURN_SPEC_CONST):
57653 VM_TRACE(ZEND_RETURN_SPEC_CONST)
57654 {
57655 USE_OPLINE
57656 zval *retval_ptr;
57657 zval *return_value;
57658
57659 retval_ptr = RT_CONSTANT(opline, opline->op1);
57660 return_value = EX(return_value);
57661
57662 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
57663 SAVE_OPLINE();
57664 retval_ptr = ZVAL_UNDEFINED_OP1();
57665 if (return_value) {
57666 ZVAL_NULL(return_value);
57667 }
57668 } else if (!return_value) {
57669 if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
57670 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
57671 SAVE_OPLINE();
57672 rc_dtor_func(Z_COUNTED_P(retval_ptr));
57673 }
57674 }
57675 } else {
57676 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
57677 ZVAL_COPY_VALUE(return_value, retval_ptr);
57678 if (IS_CONST == IS_CONST) {
57679 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
57680 Z_ADDREF_P(return_value);
57681 }
57682 }
57683 } else if (IS_CONST == IS_CV) {
57684 do {
57685 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57686 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
57687 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
57688 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
57689 ZVAL_COPY_VALUE(return_value, retval_ptr);
57690 if (GC_MAY_LEAK(ref)) {
57691 SAVE_OPLINE();
57692 gc_possible_root(ref);
57693 }
57694 ZVAL_NULL(retval_ptr);
57695 break;
57696 } else {
57697 Z_ADDREF_P(retval_ptr);
57698 }
57699 } else {
57700 retval_ptr = Z_REFVAL_P(retval_ptr);
57701 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57702 Z_ADDREF_P(retval_ptr);
57703 }
57704 }
57705 }
57706 ZVAL_COPY_VALUE(return_value, retval_ptr);
57707 } while (0);
57708 } else /* if (IS_CONST == IS_VAR) */ {
57709 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
57710 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
57711
57712 retval_ptr = Z_REFVAL_P(retval_ptr);
57713 ZVAL_COPY_VALUE(return_value, retval_ptr);
57714 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
57715 efree_size(ref, sizeof(zend_reference));
57716 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57717 Z_ADDREF_P(retval_ptr);
57718 }
57719 } else {
57720 ZVAL_COPY_VALUE(return_value, retval_ptr);
57721 }
57722 }
57723 }
57724
57725
57726
57727 goto zend_leave_helper_SPEC_LABEL;
57728 }
57729
57730 VM_TRACE_OP_END(ZEND_RETURN_SPEC_CONST)
57731 HYBRID_CASE(ZEND_RETURN_SPEC_OBSERVER):
57732 VM_TRACE(ZEND_RETURN_SPEC_OBSERVER)
57733 {
57734 USE_OPLINE
57735 zval *retval_ptr;
57736 zval *return_value;
57737 zval observer_retval;
57738
57739 retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
57740 return_value = EX(return_value);
57741 if (!return_value) { return_value = &observer_retval; };
57742 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
57743 SAVE_OPLINE();
57744 retval_ptr = ZVAL_UNDEFINED_OP1();
57745 if (return_value) {
57746 ZVAL_NULL(return_value);
57747 }
57748 } else if (!return_value) {
57749 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
57750 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
57751 SAVE_OPLINE();
57752 rc_dtor_func(Z_COUNTED_P(retval_ptr));
57753 }
57754 }
57755 } else {
57756 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
57757 ZVAL_COPY_VALUE(return_value, retval_ptr);
57758 if (opline->op1_type == IS_CONST) {
57759 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
57760 Z_ADDREF_P(return_value);
57761 }
57762 }
57763 } else if (opline->op1_type == IS_CV) {
57764 do {
57765 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57766 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
57767 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
57768 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
57769 ZVAL_COPY_VALUE(return_value, retval_ptr);
57770 if (GC_MAY_LEAK(ref)) {
57771 SAVE_OPLINE();
57772 gc_possible_root(ref);
57773 }
57774 ZVAL_NULL(retval_ptr);
57775 break;
57776 } else {
57777 Z_ADDREF_P(retval_ptr);
57778 }
57779 } else {
57780 retval_ptr = Z_REFVAL_P(retval_ptr);
57781 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57782 Z_ADDREF_P(retval_ptr);
57783 }
57784 }
57785 }
57786 ZVAL_COPY_VALUE(return_value, retval_ptr);
57787 } while (0);
57788 } else /* if (opline->op1_type == IS_VAR) */ {
57789 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
57790 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
57791
57792 retval_ptr = Z_REFVAL_P(retval_ptr);
57793 ZVAL_COPY_VALUE(return_value, retval_ptr);
57794 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
57795 efree_size(ref, sizeof(zend_reference));
57796 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57797 Z_ADDREF_P(retval_ptr);
57798 }
57799 } else {
57800 ZVAL_COPY_VALUE(return_value, retval_ptr);
57801 }
57802 }
57803 }
57804 SAVE_OPLINE();
57805 zend_observer_fcall_end(execute_data, return_value);
57806 if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
57807 goto zend_leave_helper_SPEC_LABEL;
57808 }
57809
57810 VM_TRACE_OP_END(ZEND_RETURN_SPEC_OBSERVER)
57811 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CONST):
57812 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CONST)
57813 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57814 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CONST)
57815 HYBRID_BREAK();
57816 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_OBSERVER):
57817 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
57818 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57819 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
57820 HYBRID_BREAK();
57821 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CONST):
57822 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CONST)
57823 ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57824 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CONST)
57825 HYBRID_BREAK();
57826 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER):
57827 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
57828 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57829 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
57830 HYBRID_BREAK();
57831 HYBRID_CASE(ZEND_THROW_SPEC_CONST):
57832 VM_TRACE(ZEND_THROW_SPEC_CONST)
57833 ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57834 VM_TRACE_OP_END(ZEND_THROW_SPEC_CONST)
57835 HYBRID_BREAK();
57836 HYBRID_CASE(ZEND_CATCH_SPEC_CONST):
57837 VM_TRACE(ZEND_CATCH_SPEC_CONST)
57838 ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57839 VM_TRACE_OP_END(ZEND_CATCH_SPEC_CONST)
57840 HYBRID_BREAK();
57841 HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST):
57842 VM_TRACE(ZEND_SEND_USER_SPEC_CONST)
57843 ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57844 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST)
57845 HYBRID_BREAK();
57846 HYBRID_CASE(ZEND_BOOL_SPEC_CONST):
57847 VM_TRACE(ZEND_BOOL_SPEC_CONST)
57848 ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57849 VM_TRACE_OP_END(ZEND_BOOL_SPEC_CONST)
57850 HYBRID_BREAK();
57851 HYBRID_CASE(ZEND_CLONE_SPEC_CONST):
57852 VM_TRACE(ZEND_CLONE_SPEC_CONST)
57853 ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57854 VM_TRACE_OP_END(ZEND_CLONE_SPEC_CONST)
57855 HYBRID_BREAK();
57856 HYBRID_CASE(ZEND_CAST_SPEC_CONST):
57857 VM_TRACE(ZEND_CAST_SPEC_CONST)
57858 ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57859 VM_TRACE_OP_END(ZEND_CAST_SPEC_CONST)
57860 HYBRID_BREAK();
57861 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST):
57862 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
57863 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57864 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
57865 HYBRID_BREAK();
57866 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER):
57867 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
57868 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57869 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
57870 HYBRID_BREAK();
57871 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CONST):
57872 VM_TRACE(ZEND_FE_RESET_R_SPEC_CONST)
57873 ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57874 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CONST)
57875 HYBRID_BREAK();
57876 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CONST):
57877 VM_TRACE(ZEND_FE_RESET_RW_SPEC_CONST)
57878 ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57879 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CONST)
57880 HYBRID_BREAK();
57881 HYBRID_CASE(ZEND_JMP_SET_SPEC_CONST):
57882 VM_TRACE(ZEND_JMP_SET_SPEC_CONST)
57883 ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57884 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CONST)
57885 HYBRID_BREAK();
57886 HYBRID_CASE(ZEND_COALESCE_SPEC_CONST):
57887 VM_TRACE(ZEND_COALESCE_SPEC_CONST)
57888 ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57889 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CONST)
57890 HYBRID_BREAK();
57891 HYBRID_CASE(ZEND_JMP_NULL_SPEC_CONST):
57892 VM_TRACE(ZEND_JMP_NULL_SPEC_CONST)
57893 ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57894 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CONST)
57895 HYBRID_BREAK();
57896 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CONST):
57897 VM_TRACE(ZEND_QM_ASSIGN_SPEC_CONST)
57898 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57899 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CONST)
57900 HYBRID_BREAK();
57901 HYBRID_CASE(ZEND_DECLARE_CLASS_SPEC_CONST):
57902 VM_TRACE(ZEND_DECLARE_CLASS_SPEC_CONST)
57903 ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57904 VM_TRACE_OP_END(ZEND_DECLARE_CLASS_SPEC_CONST)
57905 HYBRID_BREAK();
57906 HYBRID_CASE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST):
57907 VM_TRACE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
57908 ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57909 VM_TRACE_OP_END(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
57910 HYBRID_BREAK();
57911 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CONST):
57912 VM_TRACE(ZEND_YIELD_FROM_SPEC_CONST)
57913 ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57914 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CONST)
57915 HYBRID_BREAK();
57916 HYBRID_CASE(ZEND_STRLEN_SPEC_CONST):
57917 VM_TRACE(ZEND_STRLEN_SPEC_CONST)
57918 ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57919 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CONST)
57920 HYBRID_BREAK();
57921 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CONST):
57922 VM_TRACE(ZEND_TYPE_CHECK_SPEC_CONST)
57923 ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57924 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CONST)
57925 HYBRID_BREAK();
57926 HYBRID_CASE(ZEND_DEFINED_SPEC_CONST):
57927 VM_TRACE(ZEND_DEFINED_SPEC_CONST)
57928 ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57929 VM_TRACE_OP_END(ZEND_DEFINED_SPEC_CONST)
57930 HYBRID_BREAK();
57931 HYBRID_CASE(ZEND_JMP_FRAMELESS_SPEC_CONST):
57932 VM_TRACE(ZEND_JMP_FRAMELESS_SPEC_CONST)
57933 ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57934 VM_TRACE_OP_END(ZEND_JMP_FRAMELESS_SPEC_CONST)
57935 HYBRID_BREAK();
57936 HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_CONST):
57937 VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
57938 ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57939 VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
57940 HYBRID_BREAK();
57941 HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST):
57942 VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
57943 ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57944 VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
57945 HYBRID_BREAK();
57946 HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST):
57947 VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
57948 ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57949 VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
57950 HYBRID_BREAK();
57951 HYBRID_CASE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST):
57952 VM_TRACE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
57953 ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57954 VM_TRACE_OP_END(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
57955 HYBRID_BREAK();
57956 HYBRID_CASE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST):
57957 VM_TRACE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
57958 ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57959 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
57960 HYBRID_BREAK();
57961 HYBRID_CASE(ZEND_ADD_SPEC_CONST_CONST):
57962 VM_TRACE(ZEND_ADD_SPEC_CONST_CONST)
57963 ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57964 VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_CONST)
57965 HYBRID_BREAK();
57966 HYBRID_CASE(ZEND_SUB_SPEC_CONST_CONST):
57967 VM_TRACE(ZEND_SUB_SPEC_CONST_CONST)
57968 ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57969 VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_CONST)
57970 HYBRID_BREAK();
57971 HYBRID_CASE(ZEND_MUL_SPEC_CONST_CONST):
57972 VM_TRACE(ZEND_MUL_SPEC_CONST_CONST)
57973 ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57974 VM_TRACE_OP_END(ZEND_MUL_SPEC_CONST_CONST)
57975 HYBRID_BREAK();
57976 HYBRID_CASE(ZEND_DIV_SPEC_CONST_CONST):
57977 VM_TRACE(ZEND_DIV_SPEC_CONST_CONST)
57978 ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57979 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CONST)
57980 HYBRID_BREAK();
57981 HYBRID_CASE(ZEND_MOD_SPEC_CONST_CONST):
57982 VM_TRACE(ZEND_MOD_SPEC_CONST_CONST)
57983 ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57984 VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_CONST)
57985 HYBRID_BREAK();
57986 HYBRID_CASE(ZEND_SL_SPEC_CONST_CONST):
57987 VM_TRACE(ZEND_SL_SPEC_CONST_CONST)
57988 ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57989 VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_CONST)
57990 HYBRID_BREAK();
57991 HYBRID_CASE(ZEND_SR_SPEC_CONST_CONST):
57992 VM_TRACE(ZEND_SR_SPEC_CONST_CONST)
57993 ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57994 VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_CONST)
57995 HYBRID_BREAK();
57996 HYBRID_CASE(ZEND_POW_SPEC_CONST_CONST):
57997 VM_TRACE(ZEND_POW_SPEC_CONST_CONST)
57998 ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57999 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CONST)
58000 HYBRID_BREAK();
58001 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST):
58002 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
58003 ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58004 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
58005 HYBRID_BREAK();
58006 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST):
58007 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
58008 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58009 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
58010 HYBRID_BREAK();
58011 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CONST_CONST):
58012 VM_TRACE(ZEND_IS_EQUAL_SPEC_CONST_CONST)
58013 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58014 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CONST_CONST)
58015 HYBRID_BREAK();
58016 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST):
58017 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
58018 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58019 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
58020 HYBRID_BREAK();
58021 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_CONST):
58022 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_CONST)
58023 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58024 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_CONST)
58025 HYBRID_BREAK();
58026 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST):
58027 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
58028 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58029 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
58030 HYBRID_BREAK();
58031 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CONST):
58032 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CONST)
58033 ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58034 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CONST)
58035 HYBRID_BREAK();
58036 HYBRID_CASE(ZEND_BW_OR_SPEC_CONST_CONST):
58037 VM_TRACE(ZEND_BW_OR_SPEC_CONST_CONST)
58038 ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58039 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_CONST_CONST)
58040 HYBRID_BREAK();
58041 HYBRID_CASE(ZEND_BW_AND_SPEC_CONST_CONST):
58042 VM_TRACE(ZEND_BW_AND_SPEC_CONST_CONST)
58043 ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58044 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_CONST_CONST)
58045 HYBRID_BREAK();
58046 HYBRID_CASE(ZEND_BW_XOR_SPEC_CONST_CONST):
58047 VM_TRACE(ZEND_BW_XOR_SPEC_CONST_CONST)
58048 ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58049 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_CONST_CONST)
58050 HYBRID_BREAK();
58051 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CONST_CONST):
58052 VM_TRACE(ZEND_BOOL_XOR_SPEC_CONST_CONST)
58053 ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58054 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CONST_CONST)
58055 HYBRID_BREAK();
58056 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST):
58057 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
58058 ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58059 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
58060 HYBRID_BREAK();
58061 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST):
58062 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
58063 ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58064 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
58065 HYBRID_BREAK();
58066 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST):
58067 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
58068 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58069 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
58070 HYBRID_BREAK();
58071 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST):
58072 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
58073 ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58074 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
58075 HYBRID_BREAK();
58076 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST):
58077 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
58078 ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58079 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
58080 HYBRID_BREAK();
58081 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST):
58082 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
58083 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58084 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
58085 HYBRID_BREAK();
58086 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST):
58087 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
58088 ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58089 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
58090 HYBRID_BREAK();
58091 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CONST):
58092 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
58093 ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58094 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
58095 HYBRID_BREAK();
58096 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST):
58097 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
58098 ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58099 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
58100 HYBRID_BREAK();
58101 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST):
58102 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
58103 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58104 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
58105 HYBRID_BREAK();
58106 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST):
58107 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
58108 ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58109 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
58110 HYBRID_BREAK();
58111 HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_CONST):
58112 VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_CONST)
58113 ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58114 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_CONST)
58115 HYBRID_BREAK();
58116 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST):
58117 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
58118 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58119 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
58120 HYBRID_BREAK();
58121 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST):
58122 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
58123 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58124 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
58125 HYBRID_BREAK();
58126 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST):
58127 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
58128 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58129 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
58130 HYBRID_BREAK();
58131 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CONST):
58132 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
58133 ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58134 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
58135 HYBRID_BREAK();
58136 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST):
58137 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
58138 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58139 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
58140 HYBRID_BREAK();
58141 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST):
58142 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
58143 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58144 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
58145 HYBRID_BREAK();
58146 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST):
58147 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
58148 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58149 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
58150 HYBRID_BREAK();
58151 HYBRID_CASE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST):
58152 VM_TRACE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
58153 ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58154 VM_TRACE_OP_END(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
58155 HYBRID_BREAK();
58156 HYBRID_CASE(ZEND_DECLARE_CONST_SPEC_CONST_CONST):
58157 VM_TRACE(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
58158 ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58159 VM_TRACE_OP_END(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
58160 HYBRID_BREAK();
58161 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CONST):
58162 VM_TRACE(ZEND_YIELD_SPEC_CONST_CONST)
58163 ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58164 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CONST)
58165 HYBRID_BREAK();
58166 HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_CONST_CONST):
58167 VM_TRACE(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
58168 ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58169 VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
58170 HYBRID_BREAK();
58171 HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_CONST_CONST):
58172 VM_TRACE(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
58173 ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58174 VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
58175 HYBRID_BREAK();
58176 HYBRID_CASE(ZEND_MATCH_SPEC_CONST_CONST):
58177 VM_TRACE(ZEND_MATCH_SPEC_CONST_CONST)
58178 ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58179 VM_TRACE_OP_END(ZEND_MATCH_SPEC_CONST_CONST)
58180 HYBRID_BREAK();
58181 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CONST_CONST):
58182 VM_TRACE(ZEND_IN_ARRAY_SPEC_CONST_CONST)
58183 ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58184 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CONST_CONST)
58185 HYBRID_BREAK();
58186 HYBRID_CASE(ZEND_ADD_SPEC_CONST_TMPVARCV):
58187 VM_TRACE(ZEND_ADD_SPEC_CONST_TMPVARCV)
58188 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58189 VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_TMPVARCV)
58190 HYBRID_BREAK();
58191 HYBRID_CASE(ZEND_SUB_SPEC_CONST_TMPVARCV):
58192 VM_TRACE(ZEND_SUB_SPEC_CONST_TMPVARCV)
58193 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58194 VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_TMPVARCV)
58195 HYBRID_BREAK();
58196 HYBRID_CASE(ZEND_MOD_SPEC_CONST_TMPVARCV):
58197 VM_TRACE(ZEND_MOD_SPEC_CONST_TMPVARCV)
58198 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58199 VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_TMPVARCV)
58200 HYBRID_BREAK();
58201 HYBRID_CASE(ZEND_SL_SPEC_CONST_TMPVARCV):
58202 VM_TRACE(ZEND_SL_SPEC_CONST_TMPVARCV)
58203 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58204 VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_TMPVARCV)
58205 HYBRID_BREAK();
58206 HYBRID_CASE(ZEND_SR_SPEC_CONST_TMPVARCV):
58207 VM_TRACE(ZEND_SR_SPEC_CONST_TMPVARCV)
58208 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58209 VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_TMPVARCV)
58210 HYBRID_BREAK();
58211 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV):
58212 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
58213 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58214 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
58215 HYBRID_BREAK();
58216 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ):
58217 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
58218 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58219 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
58220 HYBRID_BREAK();
58221 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ):
58222 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
58223 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58224 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
58225 HYBRID_BREAK();
58226 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV):
58227 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
58228 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58229 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
58230 HYBRID_BREAK();
58231 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ):
58232 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
58233 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58234 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
58235 HYBRID_BREAK();
58236 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ):
58237 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
58238 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58239 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
58240 HYBRID_BREAK();
58241 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV):
58242 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
58243 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58244 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
58245 HYBRID_BREAK();
58246 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV):
58247 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
58248 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58249 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
58250 HYBRID_BREAK();
58251 HYBRID_CASE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV):
58252 VM_TRACE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
58253 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58254 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
58255 HYBRID_BREAK();
58256 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV):
58257 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
58258 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58259 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
58260 HYBRID_BREAK();
58261 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV):
58262 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
58263 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58264 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
58265 HYBRID_BREAK();
58266 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ):
58267 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
58268 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58269 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
58270 HYBRID_BREAK();
58271 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
58272 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
58273 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58274 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
58275 HYBRID_BREAK();
58276 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV):
58277 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
58278 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58279 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
58280 HYBRID_BREAK();
58281 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
58282 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
58283 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58284 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
58285 HYBRID_BREAK();
58286 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
58287 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
58288 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58289 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
58290 HYBRID_BREAK();
58291 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV):
58292 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
58293 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58294 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
58295 HYBRID_BREAK();
58296 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ):
58297 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
58298 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58299 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
58300 HYBRID_BREAK();
58301 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
58302 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
58303 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58304 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
58305 HYBRID_BREAK();
58306 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV):
58307 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
58308 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58309 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
58310 HYBRID_BREAK();
58311 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
58312 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
58313 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58314 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
58315 HYBRID_BREAK();
58316 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
58317 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
58318 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58319 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
58320 HYBRID_BREAK();
58321 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV):
58322 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
58323 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58324 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
58325 HYBRID_BREAK();
58326 HYBRID_CASE(ZEND_DIV_SPEC_CONST_TMPVAR):
58327 VM_TRACE(ZEND_DIV_SPEC_CONST_TMPVAR)
58328 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58329 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_TMPVAR)
58330 HYBRID_BREAK();
58331 HYBRID_CASE(ZEND_POW_SPEC_CONST_TMPVAR):
58332 VM_TRACE(ZEND_POW_SPEC_CONST_TMPVAR)
58333 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58334 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_TMPVAR)
58335 HYBRID_BREAK();
58336 HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_TMPVAR):
58337 VM_TRACE(ZEND_CONCAT_SPEC_CONST_TMPVAR)
58338 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58339 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_TMPVAR)
58340 HYBRID_BREAK();
58341 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR):
58342 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
58343 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58344 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
58345 HYBRID_BREAK();
58346 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR):
58347 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
58348 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58349 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
58350 HYBRID_BREAK();
58351 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR):
58352 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
58353 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58354 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
58355 HYBRID_BREAK();
58356 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR):
58357 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
58358 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58359 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
58360 HYBRID_BREAK();
58361 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR):
58362 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
58363 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58364 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
58365 HYBRID_BREAK();
58366 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR):
58367 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
58368 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58369 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
58370 HYBRID_BREAK();
58371 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR):
58372 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
58373 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58374 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
58375 HYBRID_BREAK();
58376 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR):
58377 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
58378 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58379 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
58380 HYBRID_BREAK();
58381 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR):
58382 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
58383 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58384 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
58385 HYBRID_BREAK();
58386 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR):
58387 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
58388 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58389 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
58390 HYBRID_BREAK();
58391 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR):
58392 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
58393 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58394 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
58395 HYBRID_BREAK();
58396 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR):
58397 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
58398 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58399 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
58400 HYBRID_BREAK();
58401 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR):
58402 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
58403 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58404 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
58405 HYBRID_BREAK();
58406 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR):
58407 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
58408 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58409 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
58410 HYBRID_BREAK();
58411 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR):
58412 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
58413 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58414 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
58415 HYBRID_BREAK();
58416 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR):
58417 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
58418 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58419 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
58420 HYBRID_BREAK();
58421 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR):
58422 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
58423 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58424 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
58425 HYBRID_BREAK();
58426 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_TMPVAR):
58427 VM_TRACE(ZEND_YIELD_SPEC_CONST_TMPVAR)
58428 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58429 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_TMPVAR)
58430 HYBRID_BREAK();
58431 HYBRID_CASE(ZEND_FETCH_R_SPEC_CONST_UNUSED):
58432 VM_TRACE(ZEND_FETCH_R_SPEC_CONST_UNUSED)
58433 ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58434 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CONST_UNUSED)
58435 HYBRID_BREAK();
58436 HYBRID_CASE(ZEND_FETCH_W_SPEC_CONST_UNUSED):
58437 VM_TRACE(ZEND_FETCH_W_SPEC_CONST_UNUSED)
58438 ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58439 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CONST_UNUSED)
58440 HYBRID_BREAK();
58441 HYBRID_CASE(ZEND_FETCH_RW_SPEC_CONST_UNUSED):
58442 VM_TRACE(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
58443 ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58444 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
58445 HYBRID_BREAK();
58446 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED):
58447 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
58448 ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58449 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
58450 HYBRID_BREAK();
58451 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED):
58452 VM_TRACE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
58453 ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58454 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
58455 HYBRID_BREAK();
58456 HYBRID_CASE(ZEND_FETCH_IS_SPEC_CONST_UNUSED):
58457 VM_TRACE(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
58458 ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58459 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
58460 HYBRID_BREAK();
58461 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED):
58462 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
58463 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58464 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
58465 HYBRID_BREAK();
58466 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED):
58467 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
58468 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58469 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
58470 HYBRID_BREAK();
58471 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED):
58472 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
58473 ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58474 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
58475 HYBRID_BREAK();
58476 HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_UNUSED):
58477 VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
58478 ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58479 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
58480 HYBRID_BREAK();
58481 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED):
58482 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
58483 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58484 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
58485 HYBRID_BREAK();
58486 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK):
58487 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
58488 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58489 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
58490 HYBRID_BREAK();
58491 HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED):
58492 VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED)
58493 ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58494 VM_TRACE_OP_END(ZEND_NEW_SPEC_CONST_UNUSED)
58495 HYBRID_BREAK();
58496 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED):
58497 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
58498 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58499 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
58500 HYBRID_BREAK();
58501 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED):
58502 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
58503 ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58504 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
58505 HYBRID_BREAK();
58506 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED):
58507 VM_TRACE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
58508 ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58509 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
58510 HYBRID_BREAK();
58511 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED):
58512 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
58513 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58514 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
58515 HYBRID_BREAK();
58516 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_UNUSED):
58517 VM_TRACE(ZEND_YIELD_SPEC_CONST_UNUSED)
58518 ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58519 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_UNUSED)
58520 HYBRID_BREAK();
58521 HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED):
58522 VM_TRACE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
58523 ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58524 VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
58525 HYBRID_BREAK();
58526 HYBRID_CASE(ZEND_COUNT_SPEC_CONST_UNUSED):
58527 VM_TRACE(ZEND_COUNT_SPEC_CONST_UNUSED)
58528 ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58529 VM_TRACE_OP_END(ZEND_COUNT_SPEC_CONST_UNUSED)
58530 HYBRID_BREAK();
58531 HYBRID_CASE(ZEND_GET_CLASS_SPEC_CONST_UNUSED):
58532 VM_TRACE(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
58533 ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58534 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
58535 HYBRID_BREAK();
58536 HYBRID_CASE(ZEND_GET_TYPE_SPEC_CONST_UNUSED):
58537 VM_TRACE(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
58538 ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58539 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
58540 HYBRID_BREAK();
58541 HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED):
58542 VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
58543 ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58544 VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
58545 HYBRID_BREAK();
58546 HYBRID_CASE(ZEND_DIV_SPEC_CONST_CV):
58547 VM_TRACE(ZEND_DIV_SPEC_CONST_CV)
58548 ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58549 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CV)
58550 HYBRID_BREAK();
58551 HYBRID_CASE(ZEND_POW_SPEC_CONST_CV):
58552 VM_TRACE(ZEND_POW_SPEC_CONST_CV)
58553 ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58554 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CV)
58555 HYBRID_BREAK();
58556 HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_CV):
58557 VM_TRACE(ZEND_CONCAT_SPEC_CONST_CV)
58558 ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58559 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_CV)
58560 HYBRID_BREAK();
58561 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CV):
58562 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CV)
58563 ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58564 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CV)
58565 HYBRID_BREAK();
58566 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CV):
58567 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
58568 ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58569 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
58570 HYBRID_BREAK();
58571 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV):
58572 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
58573 ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58574 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
58575 HYBRID_BREAK();
58576 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV):
58577 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
58578 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58579 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
58580 HYBRID_BREAK();
58581 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV):
58582 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
58583 ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58584 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
58585 HYBRID_BREAK();
58586 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV):
58587 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
58588 ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58589 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
58590 HYBRID_BREAK();
58591 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV):
58592 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
58593 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58594 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
58595 HYBRID_BREAK();
58596 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CV):
58597 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
58598 ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58599 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
58600 HYBRID_BREAK();
58601 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CV):
58602 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CV)
58603 ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58604 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CV)
58605 HYBRID_BREAK();
58606 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV):
58607 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
58608 ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58609 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
58610 HYBRID_BREAK();
58611 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV):
58612 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
58613 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58614 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
58615 HYBRID_BREAK();
58616 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CV):
58617 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
58618 ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58619 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
58620 HYBRID_BREAK();
58621 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV):
58622 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
58623 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58624 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
58625 HYBRID_BREAK();
58626 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CV):
58627 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CV)
58628 ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58629 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CV)
58630 HYBRID_BREAK();
58631 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV):
58632 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
58633 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58634 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
58635 HYBRID_BREAK();
58636 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV):
58637 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
58638 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58639 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
58640 HYBRID_BREAK();
58641 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV):
58642 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
58643 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58644 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
58645 HYBRID_BREAK();
58646 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CV):
58647 VM_TRACE(ZEND_YIELD_SPEC_CONST_CV)
58648 ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58649 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CV)
58650 HYBRID_BREAK();
58651 HYBRID_CASE(ZEND_BW_NOT_SPEC_TMPVARCV):
58652 VM_TRACE(ZEND_BW_NOT_SPEC_TMPVARCV)
58653 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58654 VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_TMPVARCV)
58655 HYBRID_BREAK();
58656 HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV):
58657 VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
58658 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58659 VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
58660 HYBRID_BREAK();
58661 HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV):
58662 VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
58663 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58664 VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
58665 HYBRID_BREAK();
58666 HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV):
58667 VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
58668 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58669 VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
58670 HYBRID_BREAK();
58671 HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_CONST):
58672 VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_CONST)
58673 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58674 VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_CONST)
58675 HYBRID_BREAK();
58676 HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_CONST):
58677 VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_CONST)
58678 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58679 VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_CONST)
58680 HYBRID_BREAK();
58681 HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_CONST):
58682 VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_CONST)
58683 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58684 VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_CONST)
58685 HYBRID_BREAK();
58686 HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_CONST):
58687 VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_CONST)
58688 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58689 VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_CONST)
58690 HYBRID_BREAK();
58691 HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_CONST):
58692 VM_TRACE(ZEND_SL_SPEC_TMPVARCV_CONST)
58693 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58694 VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_CONST)
58695 HYBRID_BREAK();
58696 HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_CONST):
58697 VM_TRACE(ZEND_SR_SPEC_TMPVARCV_CONST)
58698 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58699 VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_CONST)
58700 HYBRID_BREAK();
58701 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST):
58702 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
58703 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58704 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
58705 HYBRID_BREAK();
58706 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ):
58707 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
58708 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58709 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
58710 HYBRID_BREAK();
58711 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ):
58712 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
58713 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58714 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
58715 HYBRID_BREAK();
58716 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST):
58717 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
58718 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58719 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
58720 HYBRID_BREAK();
58721 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ):
58722 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
58723 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58724 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
58725 HYBRID_BREAK();
58726 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ):
58727 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
58728 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58729 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
58730 HYBRID_BREAK();
58731 HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_CONST):
58732 VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
58733 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58734 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
58735 HYBRID_BREAK();
58736 HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_CONST):
58737 VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
58738 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58739 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
58740 HYBRID_BREAK();
58741 HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST):
58742 VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
58743 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58744 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
58745 HYBRID_BREAK();
58746 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST):
58747 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
58748 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58749 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
58750 HYBRID_BREAK();
58751 HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST):
58752 VM_TRACE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
58753 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58754 VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
58755 HYBRID_BREAK();
58756 HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST):
58757 VM_TRACE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
58758 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58759 VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
58760 HYBRID_BREAK();
58761 HYBRID_CASE(ZEND_MATCH_SPEC_TMPVARCV_CONST):
58762 VM_TRACE(ZEND_MATCH_SPEC_TMPVARCV_CONST)
58763 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58764 VM_TRACE_OP_END(ZEND_MATCH_SPEC_TMPVARCV_CONST)
58765 HYBRID_BREAK();
58766 HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
58767 VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58768 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58769 VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58770 HYBRID_BREAK();
58771 HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST):
58772 VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
58773 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58774 VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
58775 HYBRID_BREAK();
58776 HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST):
58777 VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
58778 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58779 VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
58780 HYBRID_BREAK();
58781 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
58782 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58783 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58784 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58785 HYBRID_BREAK();
58786 HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST):
58787 VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
58788 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58789 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
58790 HYBRID_BREAK();
58791 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST):
58792 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
58793 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58794 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
58795 HYBRID_BREAK();
58796 HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
58797 VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58798 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58799 VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58800 HYBRID_BREAK();
58801 HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST):
58802 VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
58803 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58804 VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
58805 HYBRID_BREAK();
58806 HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST):
58807 VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
58808 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58809 VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
58810 HYBRID_BREAK();
58811 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST):
58812 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58813 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58814 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58815 HYBRID_BREAK();
58816 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
58817 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58818 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58819 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58820 HYBRID_BREAK();
58821 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
58822 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58823 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58824 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58825 HYBRID_BREAK();
58826 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
58827 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58828 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58829 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58830 HYBRID_BREAK();
58831 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
58832 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58833 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58834 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58835 HYBRID_BREAK();
58836 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
58837 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58838 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58839 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58840 HYBRID_BREAK();
58841 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST):
58842 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58843 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58844 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58845 HYBRID_BREAK();
58846 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
58847 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58848 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58849 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58850 HYBRID_BREAK();
58851 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
58852 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58853 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58854 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58855 HYBRID_BREAK();
58856 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
58857 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58858 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58859 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58860 HYBRID_BREAK();
58861 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
58862 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58863 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58864 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58865 HYBRID_BREAK();
58866 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
58867 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58868 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58869 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58870 HYBRID_BREAK();
58871 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST):
58872 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
58873 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58874 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
58875 HYBRID_BREAK();
58876 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ):
58877 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58878 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58879 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58880 HYBRID_BREAK();
58881 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
58882 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58883 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58884 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58885 HYBRID_BREAK();
58886 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST):
58887 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
58888 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58889 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
58890 HYBRID_BREAK();
58891 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
58892 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58893 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58894 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58895 HYBRID_BREAK();
58896 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
58897 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58898 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58899 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58900 HYBRID_BREAK();
58901 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST):
58902 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58903 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58904 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58905 HYBRID_BREAK();
58906 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
58907 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58908 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58909 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58910 HYBRID_BREAK();
58911 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
58912 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58913 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58914 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58915 HYBRID_BREAK();
58916 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
58917 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58918 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58919 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58920 HYBRID_BREAK();
58921 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
58922 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58923 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58924 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58925 HYBRID_BREAK();
58926 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
58927 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58928 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58929 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58930 HYBRID_BREAK();
58931 HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV):
58932 VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
58933 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58934 VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
58935 HYBRID_BREAK();
58936 HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV):
58937 VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
58938 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58939 VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
58940 HYBRID_BREAK();
58941 HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV):
58942 VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
58943 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58944 VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
58945 HYBRID_BREAK();
58946 HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV):
58947 VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
58948 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58949 VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
58950 HYBRID_BREAK();
58951 HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV):
58952 VM_TRACE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
58953 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58954 VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
58955 HYBRID_BREAK();
58956 HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV):
58957 VM_TRACE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
58958 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58959 VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
58960 HYBRID_BREAK();
58961 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV):
58962 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
58963 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58964 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
58965 HYBRID_BREAK();
58966 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ):
58967 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
58968 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58969 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
58970 HYBRID_BREAK();
58971 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
58972 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
58973 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58974 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
58975 HYBRID_BREAK();
58976 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV):
58977 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
58978 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58979 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
58980 HYBRID_BREAK();
58981 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ):
58982 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
58983 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58984 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
58985 HYBRID_BREAK();
58986 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
58987 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
58988 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58989 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
58990 HYBRID_BREAK();
58991 HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV):
58992 VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
58993 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58994 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
58995 HYBRID_BREAK();
58996 HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV):
58997 VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
58998 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58999 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
59000 HYBRID_BREAK();
59001 HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV):
59002 VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
59003 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59004 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
59005 HYBRID_BREAK();
59006 HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
59007 VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
59008 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59009 VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
59010 HYBRID_BREAK();
59011 HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV):
59012 VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
59013 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59014 VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
59015 HYBRID_BREAK();
59016 HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59017 VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59018 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59019 VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59020 HYBRID_BREAK();
59021 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
59022 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
59023 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59024 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
59025 HYBRID_BREAK();
59026 HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV):
59027 VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
59028 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59029 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
59030 HYBRID_BREAK();
59031 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59032 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59033 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59034 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59035 HYBRID_BREAK();
59036 HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
59037 VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
59038 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59039 VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
59040 HYBRID_BREAK();
59041 HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV):
59042 VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
59043 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59044 VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
59045 HYBRID_BREAK();
59046 HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59047 VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59048 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59049 VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59050 HYBRID_BREAK();
59051 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
59052 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59053 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59054 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59055 HYBRID_BREAK();
59056 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59057 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59058 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59059 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59060 HYBRID_BREAK();
59061 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59062 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59063 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59064 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59065 HYBRID_BREAK();
59066 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59067 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59068 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59069 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59070 HYBRID_BREAK();
59071 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59072 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59073 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59074 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59075 HYBRID_BREAK();
59076 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59077 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59078 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59079 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59080 HYBRID_BREAK();
59081 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
59082 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59083 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59084 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59085 HYBRID_BREAK();
59086 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59087 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59088 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59089 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59090 HYBRID_BREAK();
59091 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59092 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59093 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59094 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59095 HYBRID_BREAK();
59096 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59097 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59098 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59099 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59100 HYBRID_BREAK();
59101 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59102 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59103 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59104 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59105 HYBRID_BREAK();
59106 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59107 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59108 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59109 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59110 HYBRID_BREAK();
59111 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV):
59112 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
59113 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59114 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
59115 HYBRID_BREAK();
59116 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59117 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59118 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59119 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59120 HYBRID_BREAK();
59121 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59122 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59123 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59124 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59125 HYBRID_BREAK();
59126 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59127 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59128 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59129 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59130 HYBRID_BREAK();
59131 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59132 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59133 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59134 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59135 HYBRID_BREAK();
59136 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59137 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59138 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59139 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59140 HYBRID_BREAK();
59141 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
59142 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59143 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59144 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59145 HYBRID_BREAK();
59146 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59147 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59148 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59149 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59150 HYBRID_BREAK();
59151 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59152 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59153 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59154 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59155 HYBRID_BREAK();
59156 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59157 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59158 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59159 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59160 HYBRID_BREAK();
59161 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59162 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59163 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59164 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59165 HYBRID_BREAK();
59166 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59167 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59168 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59169 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59170 HYBRID_BREAK();
59171 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR):
59172 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
59173 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59174 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
59175 HYBRID_BREAK();
59176 HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED):
59177 VM_TRACE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
59178 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59179 VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
59180 HYBRID_BREAK();
59181 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV):
59182 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
59183 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59184 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
59185 HYBRID_BREAK();
59186 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_TMPVAR):
59187 VM_TRACE(ZEND_BOOL_NOT_SPEC_TMPVAR)
59188 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59189 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_TMPVAR)
59190 HYBRID_BREAK();
59191 HYBRID_CASE(ZEND_ECHO_SPEC_TMPVAR):
59192 VM_TRACE(ZEND_ECHO_SPEC_TMPVAR)
59193 ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59194 VM_TRACE_OP_END(ZEND_ECHO_SPEC_TMPVAR)
59195 HYBRID_BREAK();
59196 HYBRID_CASE(ZEND_JMPZ_SPEC_TMPVAR):
59197 VM_TRACE(ZEND_JMPZ_SPEC_TMPVAR)
59198 ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59199 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_TMPVAR)
59200 HYBRID_BREAK();
59201 HYBRID_CASE(ZEND_JMPNZ_SPEC_TMPVAR):
59202 VM_TRACE(ZEND_JMPNZ_SPEC_TMPVAR)
59203 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59204 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_TMPVAR)
59205 HYBRID_BREAK();
59206 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_TMPVAR):
59207 VM_TRACE(ZEND_JMPZ_EX_SPEC_TMPVAR)
59208 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59209 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_TMPVAR)
59210 HYBRID_BREAK();
59211 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_TMPVAR):
59212 VM_TRACE(ZEND_JMPNZ_EX_SPEC_TMPVAR)
59213 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59214 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_TMPVAR)
59215 HYBRID_BREAK();
59216 HYBRID_CASE(ZEND_FREE_SPEC_TMPVAR):
59217 VM_TRACE(ZEND_FREE_SPEC_TMPVAR)
59218 ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59219 VM_TRACE_OP_END(ZEND_FREE_SPEC_TMPVAR)
59220 HYBRID_BREAK();
59221 HYBRID_CASE(ZEND_FE_FREE_SPEC_TMPVAR):
59222 VM_TRACE(ZEND_FE_FREE_SPEC_TMPVAR)
59223 ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59224 VM_TRACE_OP_END(ZEND_FE_FREE_SPEC_TMPVAR)
59225 HYBRID_BREAK();
59226 HYBRID_CASE(ZEND_THROW_SPEC_TMPVAR):
59227 VM_TRACE(ZEND_THROW_SPEC_TMPVAR)
59228 ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59229 VM_TRACE_OP_END(ZEND_THROW_SPEC_TMPVAR)
59230 HYBRID_BREAK();
59231 HYBRID_CASE(ZEND_BOOL_SPEC_TMPVAR):
59232 VM_TRACE(ZEND_BOOL_SPEC_TMPVAR)
59233 ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59234 VM_TRACE_OP_END(ZEND_BOOL_SPEC_TMPVAR)
59235 HYBRID_BREAK();
59236 HYBRID_CASE(ZEND_CLONE_SPEC_TMPVAR):
59237 VM_TRACE(ZEND_CLONE_SPEC_TMPVAR)
59238 ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59239 VM_TRACE_OP_END(ZEND_CLONE_SPEC_TMPVAR)
59240 HYBRID_BREAK();
59241 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR):
59242 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
59243 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59244 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
59245 HYBRID_BREAK();
59246 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_TMPVAR):
59247 VM_TRACE(ZEND_YIELD_FROM_SPEC_TMPVAR)
59248 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59249 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_TMPVAR)
59250 HYBRID_BREAK();
59251 HYBRID_CASE(ZEND_STRLEN_SPEC_TMPVAR):
59252 VM_TRACE(ZEND_STRLEN_SPEC_TMPVAR)
59253 ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59254 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_TMPVAR)
59255 HYBRID_BREAK();
59256 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_TMPVAR):
59257 VM_TRACE(ZEND_TYPE_CHECK_SPEC_TMPVAR)
59258 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59259 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_TMPVAR)
59260 HYBRID_BREAK();
59261 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR):
59262 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
59263 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59264 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
59265 HYBRID_BREAK();
59266 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CONST):
59267 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CONST)
59268 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59269 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CONST)
59270 HYBRID_BREAK();
59271 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CONST):
59272 VM_TRACE(ZEND_POW_SPEC_TMPVAR_CONST)
59273 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59274 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CONST)
59275 HYBRID_BREAK();
59276 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CONST):
59277 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CONST)
59278 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59279 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CONST)
59280 HYBRID_BREAK();
59281 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST):
59282 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
59283 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59284 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
59285 HYBRID_BREAK();
59286 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
59287 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
59288 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59289 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
59290 HYBRID_BREAK();
59291 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
59292 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
59293 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59294 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
59295 HYBRID_BREAK();
59296 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST):
59297 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
59298 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59299 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
59300 HYBRID_BREAK();
59301 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
59302 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
59303 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59304 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
59305 HYBRID_BREAK();
59306 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
59307 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
59308 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59309 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
59310 HYBRID_BREAK();
59311 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST):
59312 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
59313 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59314 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
59315 HYBRID_BREAK();
59316 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST):
59317 VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
59318 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59319 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
59320 HYBRID_BREAK();
59321 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST):
59322 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
59323 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59324 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
59325 HYBRID_BREAK();
59326 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST):
59327 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
59328 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59329 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
59330 HYBRID_BREAK();
59331 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST):
59332 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
59333 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59334 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
59335 HYBRID_BREAK();
59336 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST):
59337 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
59338 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59339 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
59340 HYBRID_BREAK();
59341 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST):
59342 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
59343 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59344 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
59345 HYBRID_BREAK();
59346 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST):
59347 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
59348 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59349 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
59350 HYBRID_BREAK();
59351 HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST):
59352 VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
59353 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59354 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
59355 HYBRID_BREAK();
59356 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CONST):
59357 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CONST)
59358 ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59359 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CONST)
59360 HYBRID_BREAK();
59361 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST):
59362 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
59363 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59364 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
59365 HYBRID_BREAK();
59366 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST):
59367 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
59368 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59369 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
59370 HYBRID_BREAK();
59371 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST):
59372 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
59373 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59374 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
59375 HYBRID_BREAK();
59376 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST):
59377 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
59378 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59379 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
59380 HYBRID_BREAK();
59381 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST):
59382 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
59383 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59384 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
59385 HYBRID_BREAK();
59386 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV):
59387 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
59388 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59389 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
59390 HYBRID_BREAK();
59391 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_TMPVAR):
59392 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
59393 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59394 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
59395 HYBRID_BREAK();
59396 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_TMPVAR):
59397 VM_TRACE(ZEND_POW_SPEC_TMPVAR_TMPVAR)
59398 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59399 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_TMPVAR)
59400 HYBRID_BREAK();
59401 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR):
59402 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
59403 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59404 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
59405 HYBRID_BREAK();
59406 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR):
59407 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
59408 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59409 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
59410 HYBRID_BREAK();
59411 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
59412 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
59413 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59414 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
59415 HYBRID_BREAK();
59416 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
59417 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
59418 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59419 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
59420 HYBRID_BREAK();
59421 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR):
59422 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
59423 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59424 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
59425 HYBRID_BREAK();
59426 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
59427 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
59428 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59429 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
59430 HYBRID_BREAK();
59431 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
59432 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
59433 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59434 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
59435 HYBRID_BREAK();
59436 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR):
59437 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
59438 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59439 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
59440 HYBRID_BREAK();
59441 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR):
59442 VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
59443 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59444 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
59445 HYBRID_BREAK();
59446 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR):
59447 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
59448 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59449 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
59450 HYBRID_BREAK();
59451 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR):
59452 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
59453 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59454 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
59455 HYBRID_BREAK();
59456 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR):
59457 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
59458 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59459 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
59460 HYBRID_BREAK();
59461 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR):
59462 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
59463 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59464 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
59465 HYBRID_BREAK();
59466 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR):
59467 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
59468 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59469 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
59470 HYBRID_BREAK();
59471 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR):
59472 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
59473 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59474 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
59475 HYBRID_BREAK();
59476 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_TMPVAR):
59477 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
59478 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59479 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
59480 HYBRID_BREAK();
59481 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR):
59482 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
59483 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59484 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
59485 HYBRID_BREAK();
59486 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR):
59487 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
59488 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59489 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
59490 HYBRID_BREAK();
59491 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR):
59492 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
59493 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59494 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
59495 HYBRID_BREAK();
59496 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR):
59497 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
59498 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59499 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
59500 HYBRID_BREAK();
59501 HYBRID_CASE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED):
59502 VM_TRACE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
59503 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59504 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
59505 HYBRID_BREAK();
59506 HYBRID_CASE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED):
59507 VM_TRACE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
59508 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59509 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
59510 HYBRID_BREAK();
59511 HYBRID_CASE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED):
59512 VM_TRACE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
59513 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59514 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
59515 HYBRID_BREAK();
59516 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED):
59517 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
59518 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59519 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
59520 HYBRID_BREAK();
59521 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED):
59522 VM_TRACE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
59523 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59524 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
59525 HYBRID_BREAK();
59526 HYBRID_CASE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED):
59527 VM_TRACE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
59528 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59529 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
59530 HYBRID_BREAK();
59531 HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED):
59532 VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
59533 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59534 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
59535 HYBRID_BREAK();
59536 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED):
59537 VM_TRACE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
59538 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59539 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
59540 HYBRID_BREAK();
59541 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED):
59542 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
59543 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59544 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
59545 HYBRID_BREAK();
59546 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED):
59547 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
59548 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59549 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
59550 HYBRID_BREAK();
59551 HYBRID_CASE(ZEND_COUNT_SPEC_TMPVAR_UNUSED):
59552 VM_TRACE(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
59553 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59554 VM_TRACE_OP_END(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
59555 HYBRID_BREAK();
59556 HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED):
59557 VM_TRACE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
59558 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59559 VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
59560 HYBRID_BREAK();
59561 HYBRID_CASE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED):
59562 VM_TRACE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
59563 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59564 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
59565 HYBRID_BREAK();
59566 HYBRID_CASE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED):
59567 VM_TRACE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
59568 ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59569 VM_TRACE_OP_END(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
59570 HYBRID_BREAK();
59571 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CV):
59572 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CV)
59573 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59574 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CV)
59575 HYBRID_BREAK();
59576 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CV):
59577 VM_TRACE(ZEND_POW_SPEC_TMPVAR_CV)
59578 ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59579 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CV)
59580 HYBRID_BREAK();
59581 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CV):
59582 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CV)
59583 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59584 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CV)
59585 HYBRID_BREAK();
59586 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CV):
59587 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
59588 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59589 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
59590 HYBRID_BREAK();
59591 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV):
59592 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
59593 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59594 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
59595 HYBRID_BREAK();
59596 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV):
59597 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
59598 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59599 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
59600 HYBRID_BREAK();
59601 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV):
59602 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
59603 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59604 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
59605 HYBRID_BREAK();
59606 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV):
59607 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
59608 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59609 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
59610 HYBRID_BREAK();
59611 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV):
59612 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
59613 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59614 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
59615 HYBRID_BREAK();
59616 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV):
59617 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
59618 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59619 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
59620 HYBRID_BREAK();
59621 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CV):
59622 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CV)
59623 ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59624 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CV)
59625 HYBRID_BREAK();
59626 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV):
59627 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
59628 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59629 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
59630 HYBRID_BREAK();
59631 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV):
59632 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
59633 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59634 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
59635 HYBRID_BREAK();
59636 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV):
59637 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
59638 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59639 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
59640 HYBRID_BREAK();
59641 HYBRID_CASE(ZEND_RETURN_SPEC_TMP):
59642 VM_TRACE(ZEND_RETURN_SPEC_TMP)
59643 {
59644 USE_OPLINE
59645 zval *retval_ptr;
59646 zval *return_value;
59647
59648 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
59649 return_value = EX(return_value);
59650
59651 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59652 SAVE_OPLINE();
59653 retval_ptr = ZVAL_UNDEFINED_OP1();
59654 if (return_value) {
59655 ZVAL_NULL(return_value);
59656 }
59657 } else if (!return_value) {
59658 if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
59659 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
59660 SAVE_OPLINE();
59661 rc_dtor_func(Z_COUNTED_P(retval_ptr));
59662 }
59663 }
59664 } else {
59665 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
59666 ZVAL_COPY_VALUE(return_value, retval_ptr);
59667 if (IS_TMP_VAR == IS_CONST) {
59668 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
59669 Z_ADDREF_P(return_value);
59670 }
59671 }
59672 } else if (IS_TMP_VAR == IS_CV) {
59673 do {
59674 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59675 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
59676 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
59677 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59678 ZVAL_COPY_VALUE(return_value, retval_ptr);
59679 if (GC_MAY_LEAK(ref)) {
59680 SAVE_OPLINE();
59681 gc_possible_root(ref);
59682 }
59683 ZVAL_NULL(retval_ptr);
59684 break;
59685 } else {
59686 Z_ADDREF_P(retval_ptr);
59687 }
59688 } else {
59689 retval_ptr = Z_REFVAL_P(retval_ptr);
59690 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59691 Z_ADDREF_P(retval_ptr);
59692 }
59693 }
59694 }
59695 ZVAL_COPY_VALUE(return_value, retval_ptr);
59696 } while (0);
59697 } else /* if (IS_TMP_VAR == IS_VAR) */ {
59698 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
59699 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59700
59701 retval_ptr = Z_REFVAL_P(retval_ptr);
59702 ZVAL_COPY_VALUE(return_value, retval_ptr);
59703 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
59704 efree_size(ref, sizeof(zend_reference));
59705 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59706 Z_ADDREF_P(retval_ptr);
59707 }
59708 } else {
59709 ZVAL_COPY_VALUE(return_value, retval_ptr);
59710 }
59711 }
59712 }
59713
59714
59715
59716 goto zend_leave_helper_SPEC_LABEL;
59717 }
59718
59719 VM_TRACE_OP_END(ZEND_RETURN_SPEC_TMP)
59720 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_TMP):
59721 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_TMP)
59722 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59723 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_TMP)
59724 HYBRID_BREAK();
59725 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_TMP):
59726 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP)
59727 ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59728 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_TMP)
59729 HYBRID_BREAK();
59730 HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP):
59731 VM_TRACE(ZEND_SEND_USER_SPEC_TMP)
59732 ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59733 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP)
59734 HYBRID_BREAK();
59735 HYBRID_CASE(ZEND_CAST_SPEC_TMP):
59736 VM_TRACE(ZEND_CAST_SPEC_TMP)
59737 ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59738 VM_TRACE_OP_END(ZEND_CAST_SPEC_TMP)
59739 HYBRID_BREAK();
59740 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_TMP):
59741 VM_TRACE(ZEND_FE_RESET_R_SPEC_TMP)
59742 ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59743 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_TMP)
59744 HYBRID_BREAK();
59745 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_TMP):
59746 VM_TRACE(ZEND_FE_RESET_RW_SPEC_TMP)
59747 ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59748 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_TMP)
59749 HYBRID_BREAK();
59750 HYBRID_CASE(ZEND_END_SILENCE_SPEC_TMP):
59751 VM_TRACE(ZEND_END_SILENCE_SPEC_TMP)
59752 ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59753 VM_TRACE_OP_END(ZEND_END_SILENCE_SPEC_TMP)
59754 HYBRID_BREAK();
59755 HYBRID_CASE(ZEND_JMP_SET_SPEC_TMP):
59756 VM_TRACE(ZEND_JMP_SET_SPEC_TMP)
59757 ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59758 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_TMP)
59759 HYBRID_BREAK();
59760 HYBRID_CASE(ZEND_COALESCE_SPEC_TMP):
59761 VM_TRACE(ZEND_COALESCE_SPEC_TMP)
59762 ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59763 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_TMP)
59764 HYBRID_BREAK();
59765 HYBRID_CASE(ZEND_JMP_NULL_SPEC_TMP):
59766 VM_TRACE(ZEND_JMP_NULL_SPEC_TMP)
59767 ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59768 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_TMP)
59769 HYBRID_BREAK();
59770 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_TMP):
59771 VM_TRACE(ZEND_QM_ASSIGN_SPEC_TMP)
59772 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59773 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_TMP)
59774 HYBRID_BREAK();
59775 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST):
59776 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
59777 ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59778 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
59779 HYBRID_BREAK();
59780 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CONST):
59781 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CONST)
59782 ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59783 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CONST)
59784 HYBRID_BREAK();
59785 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST):
59786 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
59787 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59788 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
59789 HYBRID_BREAK();
59790 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST):
59791 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
59792 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59793 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
59794 HYBRID_BREAK();
59795 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST):
59796 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
59797 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59798 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
59799 HYBRID_BREAK();
59800 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CONST):
59801 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CONST)
59802 ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59803 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CONST)
59804 HYBRID_BREAK();
59805 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CONST):
59806 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CONST)
59807 ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59808 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CONST)
59809 HYBRID_BREAK();
59810 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST):
59811 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
59812 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59813 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
59814 HYBRID_BREAK();
59815 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST):
59816 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
59817 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59818 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
59819 HYBRID_BREAK();
59820 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CONST):
59821 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
59822 ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59823 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
59824 HYBRID_BREAK();
59825 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CONST):
59826 VM_TRACE(ZEND_YIELD_SPEC_TMP_CONST)
59827 ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59828 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CONST)
59829 HYBRID_BREAK();
59830 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_TMP_CONST):
59831 VM_TRACE(ZEND_IN_ARRAY_SPEC_TMP_CONST)
59832 ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59833 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_TMP_CONST)
59834 HYBRID_BREAK();
59835 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR):
59836 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
59837 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59838 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
59839 HYBRID_BREAK();
59840 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR):
59841 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
59842 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59843 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
59844 HYBRID_BREAK();
59845 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR):
59846 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
59847 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59848 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
59849 HYBRID_BREAK();
59850 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_TMPVAR):
59851 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
59852 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59853 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
59854 HYBRID_BREAK();
59855 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR):
59856 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
59857 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59858 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
59859 HYBRID_BREAK();
59860 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR):
59861 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
59862 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59863 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
59864 HYBRID_BREAK();
59865 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_TMPVAR):
59866 VM_TRACE(ZEND_YIELD_SPEC_TMP_TMPVAR)
59867 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59868 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_TMPVAR)
59869 HYBRID_BREAK();
59870 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP):
59871 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
59872 ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59873 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
59874 HYBRID_BREAK();
59875 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_TMP):
59876 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_TMP)
59877 ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59878 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_TMP)
59879 HYBRID_BREAK();
59880 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP):
59881 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
59882 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59883 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
59884 HYBRID_BREAK();
59885 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_VAR):
59886 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_VAR)
59887 ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59888 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_VAR)
59889 HYBRID_BREAK();
59890 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED):
59891 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
59892 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59893 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
59894 HYBRID_BREAK();
59895 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED):
59896 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
59897 ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59898 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
59899 HYBRID_BREAK();
59900 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED):
59901 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
59902 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59903 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
59904 HYBRID_BREAK();
59905 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK):
59906 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
59907 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59908 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
59909 HYBRID_BREAK();
59910 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED):
59911 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
59912 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59913 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
59914 HYBRID_BREAK();
59915 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED):
59916 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
59917 ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59918 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
59919 HYBRID_BREAK();
59920 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_UNUSED):
59921 VM_TRACE(ZEND_YIELD_SPEC_TMP_UNUSED)
59922 ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59923 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_UNUSED)
59924 HYBRID_BREAK();
59925 HYBRID_CASE(ZEND_GET_TYPE_SPEC_TMP_UNUSED):
59926 VM_TRACE(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
59927 ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59928 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
59929 HYBRID_BREAK();
59930 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CV):
59931 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CV)
59932 ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59933 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CV)
59934 HYBRID_BREAK();
59935 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV):
59936 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
59937 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59938 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
59939 HYBRID_BREAK();
59940 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV):
59941 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
59942 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59943 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
59944 HYBRID_BREAK();
59945 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CV):
59946 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CV)
59947 ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59948 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CV)
59949 HYBRID_BREAK();
59950 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CV):
59951 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CV)
59952 ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59953 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CV)
59954 HYBRID_BREAK();
59955 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV):
59956 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
59957 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59958 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
59959 HYBRID_BREAK();
59960 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CV):
59961 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CV)
59962 ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59963 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CV)
59964 HYBRID_BREAK();
59965 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CV):
59966 VM_TRACE(ZEND_YIELD_SPEC_TMP_CV)
59967 ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59968 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CV)
59969 HYBRID_BREAK();
59970 HYBRID_CASE(ZEND_BIND_LEXICAL_SPEC_TMP_CV):
59971 VM_TRACE(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
59972 ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59973 VM_TRACE_OP_END(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
59974 HYBRID_BREAK();
59975 HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED):
59976 VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
59977 ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59978 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
59979 HYBRID_BREAK();
59980 HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED):
59981 VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
59982 ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59983 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
59984 HYBRID_BREAK();
59985 HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED):
59986 VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
59987 ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59988 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
59989 HYBRID_BREAK();
59990 HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED):
59991 VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
59992 ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59993 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
59994 HYBRID_BREAK();
59995 HYBRID_CASE(ZEND_POST_INC_SPEC_VAR):
59996 VM_TRACE(ZEND_POST_INC_SPEC_VAR)
59997 ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59998 VM_TRACE_OP_END(ZEND_POST_INC_SPEC_VAR)
59999 HYBRID_BREAK();
60000 HYBRID_CASE(ZEND_POST_DEC_SPEC_VAR):
60001 VM_TRACE(ZEND_POST_DEC_SPEC_VAR)
60002 ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60003 VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_VAR)
60004 HYBRID_BREAK();
60005 HYBRID_CASE(ZEND_RETURN_SPEC_VAR):
60006 VM_TRACE(ZEND_RETURN_SPEC_VAR)
60007 {
60008 USE_OPLINE
60009 zval *retval_ptr;
60010 zval *return_value;
60011
60012 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
60013 return_value = EX(return_value);
60014
60015 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
60016 SAVE_OPLINE();
60017 retval_ptr = ZVAL_UNDEFINED_OP1();
60018 if (return_value) {
60019 ZVAL_NULL(return_value);
60020 }
60021 } else if (!return_value) {
60022 if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
60023 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
60024 SAVE_OPLINE();
60025 rc_dtor_func(Z_COUNTED_P(retval_ptr));
60026 }
60027 }
60028 } else {
60029 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
60030 ZVAL_COPY_VALUE(return_value, retval_ptr);
60031 if (IS_VAR == IS_CONST) {
60032 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
60033 Z_ADDREF_P(return_value);
60034 }
60035 }
60036 } else if (IS_VAR == IS_CV) {
60037 do {
60038 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
60039 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
60040 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
60041 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
60042 ZVAL_COPY_VALUE(return_value, retval_ptr);
60043 if (GC_MAY_LEAK(ref)) {
60044 SAVE_OPLINE();
60045 gc_possible_root(ref);
60046 }
60047 ZVAL_NULL(retval_ptr);
60048 break;
60049 } else {
60050 Z_ADDREF_P(retval_ptr);
60051 }
60052 } else {
60053 retval_ptr = Z_REFVAL_P(retval_ptr);
60054 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
60055 Z_ADDREF_P(retval_ptr);
60056 }
60057 }
60058 }
60059 ZVAL_COPY_VALUE(return_value, retval_ptr);
60060 } while (0);
60061 } else /* if (IS_VAR == IS_VAR) */ {
60062 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
60063 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
60064
60065 retval_ptr = Z_REFVAL_P(retval_ptr);
60066 ZVAL_COPY_VALUE(return_value, retval_ptr);
60067 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
60068 efree_size(ref, sizeof(zend_reference));
60069 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
60070 Z_ADDREF_P(retval_ptr);
60071 }
60072 } else {
60073 ZVAL_COPY_VALUE(return_value, retval_ptr);
60074 }
60075 }
60076 }
60077
60078
60079
60080 goto zend_leave_helper_SPEC_LABEL;
60081 }
60082
60083 VM_TRACE_OP_END(ZEND_RETURN_SPEC_VAR)
60084 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_VAR):
60085 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR)
60086 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60087 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_VAR)
60088 HYBRID_BREAK();
60089 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_VAR):
60090 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR)
60091 ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60092 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_VAR)
60093 HYBRID_BREAK();
60094 HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR):
60095 VM_TRACE(ZEND_SEND_USER_SPEC_VAR)
60096 ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60097 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_VAR)
60098 HYBRID_BREAK();
60099 HYBRID_CASE(ZEND_CAST_SPEC_VAR):
60100 VM_TRACE(ZEND_CAST_SPEC_VAR)
60101 ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60102 VM_TRACE_OP_END(ZEND_CAST_SPEC_VAR)
60103 HYBRID_BREAK();
60104 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_VAR):
60105 VM_TRACE(ZEND_FE_RESET_R_SPEC_VAR)
60106 ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60107 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_VAR)
60108 HYBRID_BREAK();
60109 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_VAR):
60110 VM_TRACE(ZEND_FE_RESET_RW_SPEC_VAR)
60111 ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60112 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_VAR)
60113 HYBRID_BREAK();
60114 HYBRID_CASE(ZEND_FE_FETCH_R_SPEC_VAR):
60115 VM_TRACE(ZEND_FE_FETCH_R_SPEC_VAR)
60116 ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60117 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SPEC_VAR)
60118 HYBRID_BREAK();
60119 HYBRID_CASE(ZEND_FE_FETCH_RW_SPEC_VAR):
60120 VM_TRACE(ZEND_FE_FETCH_RW_SPEC_VAR)
60121 ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60122 VM_TRACE_OP_END(ZEND_FE_FETCH_RW_SPEC_VAR)
60123 HYBRID_BREAK();
60124 HYBRID_CASE(ZEND_JMP_SET_SPEC_VAR):
60125 VM_TRACE(ZEND_JMP_SET_SPEC_VAR)
60126 ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60127 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_VAR)
60128 HYBRID_BREAK();
60129 HYBRID_CASE(ZEND_COALESCE_SPEC_VAR):
60130 VM_TRACE(ZEND_COALESCE_SPEC_VAR)
60131 ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60132 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_VAR)
60133 HYBRID_BREAK();
60134 HYBRID_CASE(ZEND_JMP_NULL_SPEC_VAR):
60135 VM_TRACE(ZEND_JMP_NULL_SPEC_VAR)
60136 ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60137 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_VAR)
60138 HYBRID_BREAK();
60139 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_VAR):
60140 VM_TRACE(ZEND_QM_ASSIGN_SPEC_VAR)
60141 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60142 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_VAR)
60143 HYBRID_BREAK();
60144 HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR):
60145 VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
60146 ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60147 VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
60148 HYBRID_BREAK();
60149 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST):
60150 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
60151 ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60152 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
60153 HYBRID_BREAK();
60154 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CONST):
60155 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CONST)
60156 ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60157 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CONST)
60158 HYBRID_BREAK();
60159 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST):
60160 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
60161 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60162 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
60163 HYBRID_BREAK();
60164 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST):
60165 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
60166 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60167 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
60168 HYBRID_BREAK();
60169 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST):
60170 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
60171 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60172 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
60173 HYBRID_BREAK();
60174 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CONST):
60175 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
60176 ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60177 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
60178 HYBRID_BREAK();
60179 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST):
60180 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
60181 ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60182 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
60183 HYBRID_BREAK();
60184 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST):
60185 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
60186 ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60187 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
60188 HYBRID_BREAK();
60189 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST):
60190 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
60191 ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60192 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
60193 HYBRID_BREAK();
60194 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST):
60195 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
60196 ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60197 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
60198 HYBRID_BREAK();
60199 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST):
60200 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
60201 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60202 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
60203 HYBRID_BREAK();
60204 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST):
60205 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
60206 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60207 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
60208 HYBRID_BREAK();
60209 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST):
60210 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
60211 ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60212 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
60213 HYBRID_BREAK();
60214 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST):
60215 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
60216 ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60217 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
60218 HYBRID_BREAK();
60219 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST):
60220 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
60221 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60222 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
60223 HYBRID_BREAK();
60224 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST):
60225 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
60226 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60227 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
60228 HYBRID_BREAK();
60229 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST):
60230 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
60231 ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60232 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
60233 HYBRID_BREAK();
60234 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST):
60235 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
60236 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60237 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
60238 HYBRID_BREAK();
60239 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP):
60240 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
60241 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60242 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
60243 HYBRID_BREAK();
60244 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR):
60245 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
60246 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60247 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
60248 HYBRID_BREAK();
60249 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV):
60250 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
60251 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60252 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
60253 HYBRID_BREAK();
60254 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST):
60255 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
60256 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60257 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
60258 HYBRID_BREAK();
60259 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP):
60260 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
60261 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60262 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
60263 HYBRID_BREAK();
60264 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR):
60265 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
60266 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60267 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
60268 HYBRID_BREAK();
60269 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV):
60270 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
60271 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60272 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
60273 HYBRID_BREAK();
60274 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED):
60275 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
60276 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60277 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
60278 HYBRID_BREAK();
60279 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED):
60280 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
60281 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60282 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
60283 HYBRID_BREAK();
60284 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR):
60285 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
60286 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60287 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
60288 HYBRID_BREAK();
60289 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV):
60290 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
60291 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60292 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
60293 HYBRID_BREAK();
60294 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST):
60295 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
60296 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60297 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
60298 HYBRID_BREAK();
60299 HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_CONST):
60300 VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_CONST)
60301 ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60302 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_CONST)
60303 HYBRID_BREAK();
60304 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST):
60305 VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
60306 ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60307 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
60308 HYBRID_BREAK();
60309 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST):
60310 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
60311 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60312 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
60313 HYBRID_BREAK();
60314 HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_CONST):
60315 VM_TRACE(ZEND_SEND_REF_SPEC_VAR_CONST)
60316 ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60317 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_CONST)
60318 HYBRID_BREAK();
60319 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST):
60320 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
60321 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60322 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
60323 HYBRID_BREAK();
60324 HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST):
60325 VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
60326 ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60327 VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
60328 HYBRID_BREAK();
60329 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST):
60330 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
60331 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60332 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
60333 HYBRID_BREAK();
60334 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST):
60335 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
60336 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60337 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
60338 HYBRID_BREAK();
60339 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CONST):
60340 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
60341 ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60342 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
60343 HYBRID_BREAK();
60344 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CONST):
60345 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CONST)
60346 ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60347 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CONST)
60348 HYBRID_BREAK();
60349 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CONST):
60350 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
60351 ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60352 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
60353 HYBRID_BREAK();
60354 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CONST):
60355 VM_TRACE(ZEND_YIELD_SPEC_VAR_CONST)
60356 ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60357 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CONST)
60358 HYBRID_BREAK();
60359 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_VAR_CONST):
60360 VM_TRACE(ZEND_IN_ARRAY_SPEC_VAR_CONST)
60361 ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60362 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_VAR_CONST)
60363 HYBRID_BREAK();
60364 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV):
60365 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
60366 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60367 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
60368 HYBRID_BREAK();
60369 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR):
60370 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
60371 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60372 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
60373 HYBRID_BREAK();
60374 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR):
60375 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
60376 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60377 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
60378 HYBRID_BREAK();
60379 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR):
60380 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
60381 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60382 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
60383 HYBRID_BREAK();
60384 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR):
60385 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
60386 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60387 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
60388 HYBRID_BREAK();
60389 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR):
60390 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
60391 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60392 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
60393 HYBRID_BREAK();
60394 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR):
60395 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
60396 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60397 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
60398 HYBRID_BREAK();
60399 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR):
60400 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
60401 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60402 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
60403 HYBRID_BREAK();
60404 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR):
60405 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
60406 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60407 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
60408 HYBRID_BREAK();
60409 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR):
60410 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
60411 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60412 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
60413 HYBRID_BREAK();
60414 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR):
60415 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
60416 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60417 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
60418 HYBRID_BREAK();
60419 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR):
60420 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
60421 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60422 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
60423 HYBRID_BREAK();
60424 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR):
60425 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
60426 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60427 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
60428 HYBRID_BREAK();
60429 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR):
60430 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
60431 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60432 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
60433 HYBRID_BREAK();
60434 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR):
60435 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
60436 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60437 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
60438 HYBRID_BREAK();
60439 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST):
60440 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
60441 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60442 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
60443 HYBRID_BREAK();
60444 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP):
60445 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
60446 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60447 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
60448 HYBRID_BREAK();
60449 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR):
60450 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60451 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60452 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60453 HYBRID_BREAK();
60454 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV):
60455 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
60456 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60457 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
60458 HYBRID_BREAK();
60459 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST):
60460 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
60461 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60462 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
60463 HYBRID_BREAK();
60464 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP):
60465 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
60466 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60467 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
60468 HYBRID_BREAK();
60469 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR):
60470 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60471 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60472 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60473 HYBRID_BREAK();
60474 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV):
60475 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
60476 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60477 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
60478 HYBRID_BREAK();
60479 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR):
60480 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60481 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60482 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60483 HYBRID_BREAK();
60484 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV):
60485 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
60486 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60487 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
60488 HYBRID_BREAK();
60489 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR):
60490 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
60491 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60492 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
60493 HYBRID_BREAK();
60494 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR):
60495 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
60496 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60497 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
60498 HYBRID_BREAK();
60499 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR):
60500 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
60501 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60502 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
60503 HYBRID_BREAK();
60504 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR):
60505 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
60506 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60507 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
60508 HYBRID_BREAK();
60509 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR):
60510 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
60511 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60512 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
60513 HYBRID_BREAK();
60514 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_TMPVAR):
60515 VM_TRACE(ZEND_YIELD_SPEC_VAR_TMPVAR)
60516 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60517 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_TMPVAR)
60518 HYBRID_BREAK();
60519 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP):
60520 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
60521 ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60522 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
60523 HYBRID_BREAK();
60524 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_TMP):
60525 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_TMP)
60526 ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60527 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_TMP)
60528 HYBRID_BREAK();
60529 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP):
60530 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
60531 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60532 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
60533 HYBRID_BREAK();
60534 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED):
60535 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
60536 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60537 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
60538 HYBRID_BREAK();
60539 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED):
60540 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
60541 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60542 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
60543 HYBRID_BREAK();
60544 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR):
60545 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
60546 ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60547 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
60548 HYBRID_BREAK();
60549 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_VAR):
60550 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_VAR)
60551 ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60552 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_VAR)
60553 HYBRID_BREAK();
60554 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR):
60555 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
60556 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60557 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
60558 HYBRID_BREAK();
60559 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED):
60560 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
60561 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60562 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
60563 HYBRID_BREAK();
60564 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED):
60565 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
60566 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60567 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
60568 HYBRID_BREAK();
60569 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_VAR):
60570 VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
60571 ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60572 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
60573 HYBRID_BREAK();
60574 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED):
60575 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
60576 ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60577 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
60578 HYBRID_BREAK();
60579 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED):
60580 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
60581 ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60582 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
60583 HYBRID_BREAK();
60584 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED):
60585 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
60586 ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60587 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
60588 HYBRID_BREAK();
60589 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED):
60590 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
60591 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60592 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
60593 HYBRID_BREAK();
60594 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST):
60595 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
60596 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60597 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
60598 HYBRID_BREAK();
60599 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP):
60600 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
60601 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60602 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
60603 HYBRID_BREAK();
60604 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR):
60605 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
60606 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60607 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
60608 HYBRID_BREAK();
60609 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV):
60610 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
60611 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60612 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
60613 HYBRID_BREAK();
60614 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED):
60615 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
60616 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60617 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
60618 HYBRID_BREAK();
60619 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED):
60620 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
60621 ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60622 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
60623 HYBRID_BREAK();
60624 HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_UNUSED):
60625 VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
60626 ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60627 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
60628 HYBRID_BREAK();
60629 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED):
60630 VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
60631 ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60632 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
60633 HYBRID_BREAK();
60634 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED):
60635 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
60636 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60637 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
60638 HYBRID_BREAK();
60639 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK):
60640 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
60641 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60642 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
60643 HYBRID_BREAK();
60644 HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_UNUSED):
60645 VM_TRACE(ZEND_SEND_REF_SPEC_VAR_UNUSED)
60646 ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60647 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_UNUSED)
60648 HYBRID_BREAK();
60649 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED):
60650 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
60651 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60652 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
60653 HYBRID_BREAK();
60654 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK):
60655 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
60656 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60657 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
60658 HYBRID_BREAK();
60659 HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED):
60660 VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
60661 ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60662 VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
60663 HYBRID_BREAK();
60664 HYBRID_CASE(ZEND_NEW_SPEC_VAR_UNUSED):
60665 VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED)
60666 ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60667 VM_TRACE_OP_END(ZEND_NEW_SPEC_VAR_UNUSED)
60668 HYBRID_BREAK();
60669 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED):
60670 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
60671 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60672 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
60673 HYBRID_BREAK();
60674 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED):
60675 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
60676 ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60677 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
60678 HYBRID_BREAK();
60679 HYBRID_CASE(ZEND_SEPARATE_SPEC_VAR_UNUSED):
60680 VM_TRACE(ZEND_SEPARATE_SPEC_VAR_UNUSED)
60681 ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60682 VM_TRACE_OP_END(ZEND_SEPARATE_SPEC_VAR_UNUSED)
60683 HYBRID_BREAK();
60684 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_UNUSED):
60685 VM_TRACE(ZEND_YIELD_SPEC_VAR_UNUSED)
60686 ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60687 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_UNUSED)
60688 HYBRID_BREAK();
60689 HYBRID_CASE(ZEND_MAKE_REF_SPEC_VAR_UNUSED):
60690 VM_TRACE(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
60691 ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60692 VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
60693 HYBRID_BREAK();
60694 HYBRID_CASE(ZEND_GET_TYPE_SPEC_VAR_UNUSED):
60695 VM_TRACE(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
60696 ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60697 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
60698 HYBRID_BREAK();
60699 HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED):
60700 VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
60701 ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60702 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
60703 HYBRID_BREAK();
60704 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CV):
60705 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CV)
60706 ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60707 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CV)
60708 HYBRID_BREAK();
60709 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV):
60710 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
60711 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60712 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
60713 HYBRID_BREAK();
60714 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV):
60715 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
60716 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60717 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
60718 HYBRID_BREAK();
60719 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CV):
60720 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CV)
60721 ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60722 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CV)
60723 HYBRID_BREAK();
60724 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV):
60725 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
60726 ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60727 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
60728 HYBRID_BREAK();
60729 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CV):
60730 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
60731 ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60732 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
60733 HYBRID_BREAK();
60734 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CV):
60735 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
60736 ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60737 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
60738 HYBRID_BREAK();
60739 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV):
60740 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
60741 ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60742 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
60743 HYBRID_BREAK();
60744 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV):
60745 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
60746 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60747 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
60748 HYBRID_BREAK();
60749 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV):
60750 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
60751 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60752 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
60753 HYBRID_BREAK();
60754 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV):
60755 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
60756 ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60757 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
60758 HYBRID_BREAK();
60759 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV):
60760 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
60761 ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60762 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
60763 HYBRID_BREAK();
60764 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV):
60765 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
60766 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60767 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
60768 HYBRID_BREAK();
60769 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV):
60770 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
60771 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60772 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
60773 HYBRID_BREAK();
60774 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CV):
60775 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
60776 ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60777 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
60778 HYBRID_BREAK();
60779 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST):
60780 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
60781 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60782 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
60783 HYBRID_BREAK();
60784 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP):
60785 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
60786 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60787 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
60788 HYBRID_BREAK();
60789 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR):
60790 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
60791 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60792 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
60793 HYBRID_BREAK();
60794 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV):
60795 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
60796 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60797 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
60798 HYBRID_BREAK();
60799 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST):
60800 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
60801 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60802 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
60803 HYBRID_BREAK();
60804 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP):
60805 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
60806 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60807 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
60808 HYBRID_BREAK();
60809 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR):
60810 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
60811 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60812 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
60813 HYBRID_BREAK();
60814 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV):
60815 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
60816 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60817 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
60818 HYBRID_BREAK();
60819 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED):
60820 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
60821 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60822 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
60823 HYBRID_BREAK();
60824 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED):
60825 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
60826 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60827 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
60828 HYBRID_BREAK();
60829 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_CV):
60830 VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_CV)
60831 ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60832 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_CV)
60833 HYBRID_BREAK();
60834 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR):
60835 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
60836 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60837 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
60838 HYBRID_BREAK();
60839 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV):
60840 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
60841 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60842 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
60843 HYBRID_BREAK();
60844 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV):
60845 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
60846 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60847 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
60848 HYBRID_BREAK();
60849 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV):
60850 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
60851 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60852 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
60853 HYBRID_BREAK();
60854 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CV):
60855 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CV)
60856 ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60857 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CV)
60858 HYBRID_BREAK();
60859 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CV):
60860 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CV)
60861 ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60862 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CV)
60863 HYBRID_BREAK();
60864 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CV):
60865 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CV)
60866 ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60867 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CV)
60868 HYBRID_BREAK();
60869 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CV):
60870 VM_TRACE(ZEND_YIELD_SPEC_VAR_CV)
60871 ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60872 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CV)
60873 HYBRID_BREAK();
60874 HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED):
60875 VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
60876 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60877 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
60878 HYBRID_BREAK();
60879 HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED):
60880 VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
60881 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60882 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
60883 HYBRID_BREAK();
60884 HYBRID_CASE(ZEND_CLONE_SPEC_UNUSED):
60885 VM_TRACE(ZEND_CLONE_SPEC_UNUSED)
60886 ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60887 VM_TRACE_OP_END(ZEND_CLONE_SPEC_UNUSED)
60888 HYBRID_BREAK();
60889 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED):
60890 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
60891 ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60892 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
60893 HYBRID_BREAK();
60894 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST):
60895 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
60896 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60897 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
60898 HYBRID_BREAK();
60899 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST):
60900 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
60901 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60902 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
60903 HYBRID_BREAK();
60904 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST):
60905 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
60906 ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60907 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
60908 HYBRID_BREAK();
60909 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST):
60910 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
60911 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60912 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
60913 HYBRID_BREAK();
60914 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST):
60915 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
60916 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60917 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
60918 HYBRID_BREAK();
60919 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST):
60920 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
60921 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60922 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
60923 HYBRID_BREAK();
60924 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST):
60925 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
60926 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60927 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
60928 HYBRID_BREAK();
60929 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST):
60930 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
60931 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60932 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
60933 HYBRID_BREAK();
60934 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST):
60935 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
60936 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60937 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
60938 HYBRID_BREAK();
60939 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST):
60940 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
60941 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60942 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
60943 HYBRID_BREAK();
60944 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP):
60945 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
60946 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60947 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
60948 HYBRID_BREAK();
60949 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR):
60950 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
60951 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60952 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
60953 HYBRID_BREAK();
60954 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV):
60955 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
60956 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60957 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
60958 HYBRID_BREAK();
60959 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR):
60960 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
60961 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60962 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
60963 HYBRID_BREAK();
60964 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV):
60965 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
60966 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60967 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
60968 HYBRID_BREAK();
60969 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST):
60970 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
60971 ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60972 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
60973 HYBRID_BREAK();
60974 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST):
60975 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
60976 ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60977 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
60978 HYBRID_BREAK();
60979 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST):
60980 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
60981 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60982 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
60983 HYBRID_BREAK();
60984 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST):
60985 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
60986 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60987 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
60988 HYBRID_BREAK();
60989 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST):
60990 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
60991 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60992 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
60993 HYBRID_BREAK();
60994 HYBRID_CASE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST):
60995 VM_TRACE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
60996 ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60997 VM_TRACE_OP_END(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
60998 HYBRID_BREAK();
60999 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST):
61000 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
61001 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61002 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
61003 HYBRID_BREAK();
61004 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST):
61005 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
61006 ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61007 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
61008 HYBRID_BREAK();
61009 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST):
61010 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
61011 ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61012 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
61013 HYBRID_BREAK();
61014 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST):
61015 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
61016 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61017 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
61018 HYBRID_BREAK();
61019 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CONST):
61020 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CONST)
61021 ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61022 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CONST)
61023 HYBRID_BREAK();
61024 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV):
61025 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
61026 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61027 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
61028 HYBRID_BREAK();
61029 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR):
61030 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
61031 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61032 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
61033 HYBRID_BREAK();
61034 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR):
61035 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
61036 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61037 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
61038 HYBRID_BREAK();
61039 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR):
61040 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
61041 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61042 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
61043 HYBRID_BREAK();
61044 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR):
61045 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
61046 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61047 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
61048 HYBRID_BREAK();
61049 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR):
61050 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
61051 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61052 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
61053 HYBRID_BREAK();
61054 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR):
61055 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
61056 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61057 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
61058 HYBRID_BREAK();
61059 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR):
61060 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
61061 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61062 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
61063 HYBRID_BREAK();
61064 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR):
61065 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
61066 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61067 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
61068 HYBRID_BREAK();
61069 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR):
61070 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
61071 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61072 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
61073 HYBRID_BREAK();
61074 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST):
61075 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
61076 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61077 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
61078 HYBRID_BREAK();
61079 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP):
61080 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
61081 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61082 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
61083 HYBRID_BREAK();
61084 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
61085 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
61086 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61087 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
61088 HYBRID_BREAK();
61089 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
61090 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
61091 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61092 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
61093 HYBRID_BREAK();
61094 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
61095 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
61096 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61097 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
61098 HYBRID_BREAK();
61099 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
61100 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
61101 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61102 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
61103 HYBRID_BREAK();
61104 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR):
61105 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
61106 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61107 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
61108 HYBRID_BREAK();
61109 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR):
61110 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
61111 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61112 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
61113 HYBRID_BREAK();
61114 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR):
61115 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
61116 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61117 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
61118 HYBRID_BREAK();
61119 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR):
61120 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
61121 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61122 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
61123 HYBRID_BREAK();
61124 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR):
61125 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
61126 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61127 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
61128 HYBRID_BREAK();
61129 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR):
61130 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
61131 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61132 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
61133 HYBRID_BREAK();
61134 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR):
61135 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
61136 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61137 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
61138 HYBRID_BREAK();
61139 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_TMPVAR):
61140 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
61141 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61142 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
61143 HYBRID_BREAK();
61144 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED):
61145 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
61146 ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61147 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
61148 HYBRID_BREAK();
61149 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED):
61150 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
61151 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61152 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
61153 HYBRID_BREAK();
61154 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED):
61155 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
61156 ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61157 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
61158 HYBRID_BREAK();
61159 HYBRID_CASE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED):
61160 VM_TRACE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
61161 ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61162 VM_TRACE_OP_END(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
61163 HYBRID_BREAK();
61164 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED):
61165 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
61166 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61167 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
61168 HYBRID_BREAK();
61169 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK):
61170 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
61171 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61172 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
61173 HYBRID_BREAK();
61174 HYBRID_CASE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED):
61175 VM_TRACE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
61176 ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61177 VM_TRACE_OP_END(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
61178 HYBRID_BREAK();
61179 HYBRID_CASE(ZEND_NEW_SPEC_UNUSED_UNUSED):
61180 VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED)
61181 ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61182 VM_TRACE_OP_END(ZEND_NEW_SPEC_UNUSED_UNUSED)
61183 HYBRID_BREAK();
61184 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED):
61185 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
61186 ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61187 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
61188 HYBRID_BREAK();
61189 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_UNUSED):
61190 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_UNUSED)
61191 ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61192 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_UNUSED)
61193 HYBRID_BREAK();
61194 HYBRID_CASE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED):
61195 VM_TRACE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
61196 ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61197 VM_TRACE_OP_END(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
61198 HYBRID_BREAK();
61199 HYBRID_CASE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED):
61200 VM_TRACE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
61201 ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61202 VM_TRACE_OP_END(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
61203 HYBRID_BREAK();
61204 HYBRID_CASE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED):
61205 VM_TRACE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
61206 ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61207 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
61208 HYBRID_BREAK();
61209 HYBRID_CASE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED):
61210 VM_TRACE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
61211 ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61212 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
61213 HYBRID_BREAK();
61214 HYBRID_CASE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED):
61215 VM_TRACE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
61216 ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61217 VM_TRACE_OP_END(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
61218 HYBRID_BREAK();
61219 HYBRID_CASE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED):
61220 VM_TRACE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
61221 ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61222 VM_TRACE_OP_END(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
61223 HYBRID_BREAK();
61224 HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED):
61225 VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
61226 ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61227 VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
61228 HYBRID_BREAK();
61229 HYBRID_CASE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED):
61230 VM_TRACE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
61231 ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61232 VM_TRACE_OP_END(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
61233 HYBRID_BREAK();
61234 HYBRID_CASE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED):
61235 VM_TRACE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
61236 ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61237 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
61238 HYBRID_BREAK();
61239 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV):
61240 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
61241 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61242 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
61243 HYBRID_BREAK();
61244 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV):
61245 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
61246 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61247 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
61248 HYBRID_BREAK();
61249 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV):
61250 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
61251 ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61252 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
61253 HYBRID_BREAK();
61254 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV):
61255 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
61256 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61257 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
61258 HYBRID_BREAK();
61259 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV):
61260 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
61261 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61262 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
61263 HYBRID_BREAK();
61264 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV):
61265 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
61266 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61267 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
61268 HYBRID_BREAK();
61269 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV):
61270 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
61271 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61272 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
61273 HYBRID_BREAK();
61274 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV):
61275 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
61276 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61277 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
61278 HYBRID_BREAK();
61279 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV):
61280 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
61281 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61282 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
61283 HYBRID_BREAK();
61284 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST):
61285 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
61286 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61287 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
61288 HYBRID_BREAK();
61289 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP):
61290 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
61291 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61292 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
61293 HYBRID_BREAK();
61294 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR):
61295 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
61296 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61297 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
61298 HYBRID_BREAK();
61299 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV):
61300 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
61301 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61302 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
61303 HYBRID_BREAK();
61304 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR):
61305 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
61306 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61307 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
61308 HYBRID_BREAK();
61309 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV):
61310 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
61311 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61312 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
61313 HYBRID_BREAK();
61314 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CV):
61315 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
61316 ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61317 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
61318 HYBRID_BREAK();
61319 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV):
61320 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
61321 ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61322 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
61323 HYBRID_BREAK();
61324 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV):
61325 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
61326 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61327 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
61328 HYBRID_BREAK();
61329 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV):
61330 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
61331 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61332 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
61333 HYBRID_BREAK();
61334 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV):
61335 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
61336 ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61337 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
61338 HYBRID_BREAK();
61339 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV):
61340 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
61341 ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61342 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
61343 HYBRID_BREAK();
61344 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV):
61345 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
61346 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61347 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
61348 HYBRID_BREAK();
61349 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CV):
61350 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CV)
61351 ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61352 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CV)
61353 HYBRID_BREAK();
61354 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CV):
61355 VM_TRACE(ZEND_BOOL_NOT_SPEC_CV)
61356 ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61357 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CV)
61358 HYBRID_BREAK();
61359 HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED):
61360 VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
61361 ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61362 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
61363 HYBRID_BREAK();
61364 HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED):
61365 VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
61366 ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61367 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
61368 HYBRID_BREAK();
61369 HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED):
61370 VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
61371 ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61372 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
61373 HYBRID_BREAK();
61374 HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED):
61375 VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
61376 ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61377 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
61378 HYBRID_BREAK();
61379 HYBRID_CASE(ZEND_POST_INC_SPEC_CV):
61380 VM_TRACE(ZEND_POST_INC_SPEC_CV)
61381 ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61382 VM_TRACE_OP_END(ZEND_POST_INC_SPEC_CV)
61383 HYBRID_BREAK();
61384 HYBRID_CASE(ZEND_POST_DEC_SPEC_CV):
61385 VM_TRACE(ZEND_POST_DEC_SPEC_CV)
61386 ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61387 VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_CV)
61388 HYBRID_BREAK();
61389 HYBRID_CASE(ZEND_ECHO_SPEC_CV):
61390 VM_TRACE(ZEND_ECHO_SPEC_CV)
61391 ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61392 VM_TRACE_OP_END(ZEND_ECHO_SPEC_CV)
61393 HYBRID_BREAK();
61394 HYBRID_CASE(ZEND_JMPZ_SPEC_CV):
61395 VM_TRACE(ZEND_JMPZ_SPEC_CV)
61396 ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61397 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CV)
61398 HYBRID_BREAK();
61399 HYBRID_CASE(ZEND_JMPNZ_SPEC_CV):
61400 VM_TRACE(ZEND_JMPNZ_SPEC_CV)
61401 ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61402 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CV)
61403 HYBRID_BREAK();
61404 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CV):
61405 VM_TRACE(ZEND_JMPZ_EX_SPEC_CV)
61406 ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61407 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CV)
61408 HYBRID_BREAK();
61409 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CV):
61410 VM_TRACE(ZEND_JMPNZ_EX_SPEC_CV)
61411 ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61412 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CV)
61413 HYBRID_BREAK();
61414 HYBRID_CASE(ZEND_RETURN_SPEC_CV):
61415 VM_TRACE(ZEND_RETURN_SPEC_CV)
61416 {
61417 USE_OPLINE
61418 zval *retval_ptr;
61419 zval *return_value;
61420
61421 retval_ptr = EX_VAR(opline->op1.var);
61422 return_value = EX(return_value);
61423
61424 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
61425 SAVE_OPLINE();
61426 retval_ptr = ZVAL_UNDEFINED_OP1();
61427 if (return_value) {
61428 ZVAL_NULL(return_value);
61429 }
61430 } else if (!return_value) {
61431 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
61432 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
61433 SAVE_OPLINE();
61434 rc_dtor_func(Z_COUNTED_P(retval_ptr));
61435 }
61436 }
61437 } else {
61438 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
61439 ZVAL_COPY_VALUE(return_value, retval_ptr);
61440 if (IS_CV == IS_CONST) {
61441 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
61442 Z_ADDREF_P(return_value);
61443 }
61444 }
61445 } else if (IS_CV == IS_CV) {
61446 do {
61447 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61448 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
61449 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
61450 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61451 ZVAL_COPY_VALUE(return_value, retval_ptr);
61452 if (GC_MAY_LEAK(ref)) {
61453 SAVE_OPLINE();
61454 gc_possible_root(ref);
61455 }
61456 ZVAL_NULL(retval_ptr);
61457 break;
61458 } else {
61459 Z_ADDREF_P(retval_ptr);
61460 }
61461 } else {
61462 retval_ptr = Z_REFVAL_P(retval_ptr);
61463 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61464 Z_ADDREF_P(retval_ptr);
61465 }
61466 }
61467 }
61468 ZVAL_COPY_VALUE(return_value, retval_ptr);
61469 } while (0);
61470 } else /* if (IS_CV == IS_VAR) */ {
61471 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
61472 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61473
61474 retval_ptr = Z_REFVAL_P(retval_ptr);
61475 ZVAL_COPY_VALUE(return_value, retval_ptr);
61476 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
61477 efree_size(ref, sizeof(zend_reference));
61478 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61479 Z_ADDREF_P(retval_ptr);
61480 }
61481 } else {
61482 ZVAL_COPY_VALUE(return_value, retval_ptr);
61483 }
61484 }
61485 }
61486
61487
61488
61489 goto zend_leave_helper_SPEC_LABEL;
61490 }
61491
61492 VM_TRACE_OP_END(ZEND_RETURN_SPEC_CV)
61493 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CV):
61494 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CV)
61495 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61496 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CV)
61497 HYBRID_BREAK();
61498 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CV):
61499 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CV)
61500 ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61501 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CV)
61502 HYBRID_BREAK();
61503 HYBRID_CASE(ZEND_THROW_SPEC_CV):
61504 VM_TRACE(ZEND_THROW_SPEC_CV)
61505 ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61506 VM_TRACE_OP_END(ZEND_THROW_SPEC_CV)
61507 HYBRID_BREAK();
61508 HYBRID_CASE(ZEND_SEND_USER_SPEC_CV):
61509 VM_TRACE(ZEND_SEND_USER_SPEC_CV)
61510 ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61511 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV)
61512 HYBRID_BREAK();
61513 HYBRID_CASE(ZEND_BOOL_SPEC_CV):
61514 VM_TRACE(ZEND_BOOL_SPEC_CV)
61515 ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61516 VM_TRACE_OP_END(ZEND_BOOL_SPEC_CV)
61517 HYBRID_BREAK();
61518 HYBRID_CASE(ZEND_CLONE_SPEC_CV):
61519 VM_TRACE(ZEND_CLONE_SPEC_CV)
61520 ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61521 VM_TRACE_OP_END(ZEND_CLONE_SPEC_CV)
61522 HYBRID_BREAK();
61523 HYBRID_CASE(ZEND_CAST_SPEC_CV):
61524 VM_TRACE(ZEND_CAST_SPEC_CV)
61525 ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61526 VM_TRACE_OP_END(ZEND_CAST_SPEC_CV)
61527 HYBRID_BREAK();
61528 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CV):
61529 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
61530 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61531 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
61532 HYBRID_BREAK();
61533 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CV):
61534 VM_TRACE(ZEND_FE_RESET_R_SPEC_CV)
61535 ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61536 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CV)
61537 HYBRID_BREAK();
61538 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CV):
61539 VM_TRACE(ZEND_FE_RESET_RW_SPEC_CV)
61540 ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61541 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CV)
61542 HYBRID_BREAK();
61543 HYBRID_CASE(ZEND_JMP_SET_SPEC_CV):
61544 VM_TRACE(ZEND_JMP_SET_SPEC_CV)
61545 ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61546 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CV)
61547 HYBRID_BREAK();
61548 HYBRID_CASE(ZEND_COALESCE_SPEC_CV):
61549 VM_TRACE(ZEND_COALESCE_SPEC_CV)
61550 ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61551 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CV)
61552 HYBRID_BREAK();
61553 HYBRID_CASE(ZEND_JMP_NULL_SPEC_CV):
61554 VM_TRACE(ZEND_JMP_NULL_SPEC_CV)
61555 ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61556 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CV)
61557 HYBRID_BREAK();
61558 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CV):
61559 VM_TRACE(ZEND_QM_ASSIGN_SPEC_CV)
61560 ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61561 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CV)
61562 HYBRID_BREAK();
61563 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CV):
61564 VM_TRACE(ZEND_YIELD_FROM_SPEC_CV)
61565 ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61566 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CV)
61567 HYBRID_BREAK();
61568 HYBRID_CASE(ZEND_STRLEN_SPEC_CV):
61569 VM_TRACE(ZEND_STRLEN_SPEC_CV)
61570 ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61571 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CV)
61572 HYBRID_BREAK();
61573 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CV):
61574 VM_TRACE(ZEND_TYPE_CHECK_SPEC_CV)
61575 ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61576 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CV)
61577 HYBRID_BREAK();
61578 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_CV):
61579 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_CV)
61580 ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61581 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_CV)
61582 HYBRID_BREAK();
61583 HYBRID_CASE(ZEND_BIND_STATIC_SPEC_CV):
61584 VM_TRACE(ZEND_BIND_STATIC_SPEC_CV)
61585 ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61586 VM_TRACE_OP_END(ZEND_BIND_STATIC_SPEC_CV)
61587 HYBRID_BREAK();
61588 HYBRID_CASE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV):
61589 VM_TRACE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
61590 ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61591 VM_TRACE_OP_END(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
61592 HYBRID_BREAK();
61593 HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
61594 VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
61595 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61596 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
61597 HYBRID_BREAK();
61598 HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
61599 VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
61600 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61601 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
61602 HYBRID_BREAK();
61603 HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED):
61604 VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
61605 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61606 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
61607 HYBRID_BREAK();
61608 HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED):
61609 VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
61610 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61611 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
61612 HYBRID_BREAK();
61613 HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
61614 VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
61615 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61616 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
61617 HYBRID_BREAK();
61618 HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
61619 VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
61620 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61621 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
61622 HYBRID_BREAK();
61623 HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED):
61624 VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
61625 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61626 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
61627 HYBRID_BREAK();
61628 HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED):
61629 VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
61630 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61631 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
61632 HYBRID_BREAK();
61633 HYBRID_CASE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV):
61634 VM_TRACE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
61635 ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61636 VM_TRACE_OP_END(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
61637 HYBRID_BREAK();
61638 HYBRID_CASE(ZEND_POST_INC_LONG_SPEC_CV):
61639 VM_TRACE(ZEND_POST_INC_LONG_SPEC_CV)
61640 ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61641 VM_TRACE_OP_END(ZEND_POST_INC_LONG_SPEC_CV)
61642 HYBRID_BREAK();
61643 HYBRID_CASE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV):
61644 VM_TRACE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
61645 ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61646 VM_TRACE_OP_END(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
61647 HYBRID_BREAK();
61648 HYBRID_CASE(ZEND_POST_DEC_LONG_SPEC_CV):
61649 VM_TRACE(ZEND_POST_DEC_LONG_SPEC_CV)
61650 ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61651 VM_TRACE_OP_END(ZEND_POST_DEC_LONG_SPEC_CV)
61652 HYBRID_BREAK();
61653 HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_CV):
61654 VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
61655 ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61656 VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
61657 HYBRID_BREAK();
61658 HYBRID_CASE(ZEND_DIV_SPEC_CV_CONST):
61659 VM_TRACE(ZEND_DIV_SPEC_CV_CONST)
61660 ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61661 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CONST)
61662 HYBRID_BREAK();
61663 HYBRID_CASE(ZEND_POW_SPEC_CV_CONST):
61664 VM_TRACE(ZEND_POW_SPEC_CV_CONST)
61665 ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61666 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CONST)
61667 HYBRID_BREAK();
61668 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CONST):
61669 VM_TRACE(ZEND_CONCAT_SPEC_CV_CONST)
61670 ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61671 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CONST)
61672 HYBRID_BREAK();
61673 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CONST):
61674 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
61675 ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61676 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
61677 HYBRID_BREAK();
61678 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST):
61679 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
61680 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61681 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
61682 HYBRID_BREAK();
61683 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST):
61684 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST)
61685 ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61686 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST)
61687 HYBRID_BREAK();
61688 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ):
61689 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
61690 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61691 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
61692 HYBRID_BREAK();
61693 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ):
61694 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
61695 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61696 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
61697 HYBRID_BREAK();
61698 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST):
61699 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
61700 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61701 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
61702 HYBRID_BREAK();
61703 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ):
61704 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
61705 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61706 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
61707 HYBRID_BREAK();
61708 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ):
61709 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
61710 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61711 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
61712 HYBRID_BREAK();
61713 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CONST):
61714 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CONST)
61715 ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61716 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CONST)
61717 HYBRID_BREAK();
61718 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CONST):
61719 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CONST)
61720 ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61721 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CONST)
61722 HYBRID_BREAK();
61723 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST):
61724 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
61725 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61726 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
61727 HYBRID_BREAK();
61728 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST):
61729 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
61730 ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61731 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
61732 HYBRID_BREAK();
61733 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CONST):
61734 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CONST)
61735 ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61736 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CONST)
61737 HYBRID_BREAK();
61738 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST):
61739 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
61740 ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61741 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
61742 HYBRID_BREAK();
61743 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CONST):
61744 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
61745 ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61746 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
61747 HYBRID_BREAK();
61748 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CONST):
61749 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
61750 ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61751 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
61752 HYBRID_BREAK();
61753 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CONST):
61754 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
61755 ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61756 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
61757 HYBRID_BREAK();
61758 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST):
61759 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
61760 ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61761 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
61762 HYBRID_BREAK();
61763 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST):
61764 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
61765 ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61766 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
61767 HYBRID_BREAK();
61768 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST):
61769 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
61770 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61771 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
61772 HYBRID_BREAK();
61773 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST):
61774 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
61775 ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61776 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
61777 HYBRID_BREAK();
61778 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST):
61779 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
61780 ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61781 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
61782 HYBRID_BREAK();
61783 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST):
61784 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
61785 ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61786 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
61787 HYBRID_BREAK();
61788 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST):
61789 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
61790 ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61791 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
61792 HYBRID_BREAK();
61793 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST):
61794 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
61795 ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61796 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
61797 HYBRID_BREAK();
61798 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST):
61799 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
61800 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61801 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
61802 HYBRID_BREAK();
61803 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST):
61804 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
61805 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61806 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
61807 HYBRID_BREAK();
61808 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST):
61809 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
61810 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61811 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
61812 HYBRID_BREAK();
61813 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP):
61814 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
61815 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61816 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
61817 HYBRID_BREAK();
61818 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR):
61819 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
61820 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61821 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
61822 HYBRID_BREAK();
61823 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV):
61824 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
61825 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61826 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
61827 HYBRID_BREAK();
61828 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST):
61829 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
61830 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61831 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
61832 HYBRID_BREAK();
61833 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP):
61834 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
61835 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61836 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
61837 HYBRID_BREAK();
61838 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR):
61839 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
61840 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61841 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
61842 HYBRID_BREAK();
61843 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV):
61844 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
61845 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61846 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
61847 HYBRID_BREAK();
61848 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED):
61849 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
61850 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61851 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
61852 HYBRID_BREAK();
61853 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED):
61854 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
61855 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61856 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
61857 HYBRID_BREAK();
61858 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR):
61859 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
61860 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61861 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
61862 HYBRID_BREAK();
61863 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV):
61864 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
61865 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61866 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
61867 HYBRID_BREAK();
61868 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CONST):
61869 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CONST)
61870 ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61871 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CONST)
61872 HYBRID_BREAK();
61873 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST):
61874 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
61875 ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61876 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
61877 HYBRID_BREAK();
61878 HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_CONST):
61879 VM_TRACE(ZEND_SEND_VAR_SPEC_CV_CONST)
61880 ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61881 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_CONST)
61882 HYBRID_BREAK();
61883 HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_CONST):
61884 VM_TRACE(ZEND_SEND_REF_SPEC_CV_CONST)
61885 ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61886 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_CONST)
61887 HYBRID_BREAK();
61888 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_CONST):
61889 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
61890 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61891 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
61892 HYBRID_BREAK();
61893 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST):
61894 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
61895 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61896 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
61897 HYBRID_BREAK();
61898 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CONST):
61899 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CONST)
61900 ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61901 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CONST)
61902 HYBRID_BREAK();
61903 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CONST):
61904 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CONST)
61905 ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61906 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CONST)
61907 HYBRID_BREAK();
61908 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CONST):
61909 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CONST)
61910 ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61911 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CONST)
61912 HYBRID_BREAK();
61913 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST):
61914 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
61915 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61916 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
61917 HYBRID_BREAK();
61918 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST):
61919 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
61920 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61921 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
61922 HYBRID_BREAK();
61923 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST):
61924 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
61925 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61926 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
61927 HYBRID_BREAK();
61928 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_CONST):
61929 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_CONST)
61930 ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61931 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_CONST)
61932 HYBRID_BREAK();
61933 HYBRID_CASE(ZEND_YIELD_SPEC_CV_CONST):
61934 VM_TRACE(ZEND_YIELD_SPEC_CV_CONST)
61935 ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61936 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CONST)
61937 HYBRID_BREAK();
61938 HYBRID_CASE(ZEND_BIND_GLOBAL_SPEC_CV_CONST):
61939 VM_TRACE(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
61940 ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61941 VM_TRACE_OP_END(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
61942 HYBRID_BREAK();
61943 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CV_CONST):
61944 VM_TRACE(ZEND_IN_ARRAY_SPEC_CV_CONST)
61945 ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61946 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CV_CONST)
61947 HYBRID_BREAK();
61948 HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST):
61949 VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
61950 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61951 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
61952 HYBRID_BREAK();
61953 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST):
61954 VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
61955 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61956 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
61957 HYBRID_BREAK();
61958 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST):
61959 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
61960 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61961 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
61962 HYBRID_BREAK();
61963 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV):
61964 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
61965 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61966 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
61967 HYBRID_BREAK();
61968 HYBRID_CASE(ZEND_DIV_SPEC_CV_TMPVAR):
61969 VM_TRACE(ZEND_DIV_SPEC_CV_TMPVAR)
61970 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61971 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_TMPVAR)
61972 HYBRID_BREAK();
61973 HYBRID_CASE(ZEND_POW_SPEC_CV_TMPVAR):
61974 VM_TRACE(ZEND_POW_SPEC_CV_TMPVAR)
61975 ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61976 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_TMPVAR)
61977 HYBRID_BREAK();
61978 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_TMPVAR):
61979 VM_TRACE(ZEND_CONCAT_SPEC_CV_TMPVAR)
61980 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61981 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_TMPVAR)
61982 HYBRID_BREAK();
61983 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR):
61984 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
61985 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61986 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
61987 HYBRID_BREAK();
61988 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ):
61989 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
61990 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61991 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
61992 HYBRID_BREAK();
61993 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
61994 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
61995 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61996 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
61997 HYBRID_BREAK();
61998 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR):
61999 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
62000 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62001 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
62002 HYBRID_BREAK();
62003 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ):
62004 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
62005 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62006 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
62007 HYBRID_BREAK();
62008 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
62009 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
62010 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62011 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
62012 HYBRID_BREAK();
62013 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_TMPVAR):
62014 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
62015 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62016 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
62017 HYBRID_BREAK();
62018 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR):
62019 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
62020 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62021 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
62022 HYBRID_BREAK();
62023 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR):
62024 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
62025 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62026 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
62027 HYBRID_BREAK();
62028 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR):
62029 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
62030 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62031 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
62032 HYBRID_BREAK();
62033 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR):
62034 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
62035 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62036 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
62037 HYBRID_BREAK();
62038 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR):
62039 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
62040 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62041 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
62042 HYBRID_BREAK();
62043 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR):
62044 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
62045 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62046 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
62047 HYBRID_BREAK();
62048 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR):
62049 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
62050 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62051 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
62052 HYBRID_BREAK();
62053 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR):
62054 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
62055 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62056 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
62057 HYBRID_BREAK();
62058 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR):
62059 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
62060 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62061 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
62062 HYBRID_BREAK();
62063 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR):
62064 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
62065 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62066 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
62067 HYBRID_BREAK();
62068 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR):
62069 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
62070 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62071 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
62072 HYBRID_BREAK();
62073 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR):
62074 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
62075 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62076 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
62077 HYBRID_BREAK();
62078 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR):
62079 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
62080 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62081 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
62082 HYBRID_BREAK();
62083 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR):
62084 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
62085 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62086 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
62087 HYBRID_BREAK();
62088 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR):
62089 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
62090 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62091 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
62092 HYBRID_BREAK();
62093 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR):
62094 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
62095 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62096 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
62097 HYBRID_BREAK();
62098 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR):
62099 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
62100 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62101 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
62102 HYBRID_BREAK();
62103 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR):
62104 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
62105 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62106 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
62107 HYBRID_BREAK();
62108 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST):
62109 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
62110 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62111 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
62112 HYBRID_BREAK();
62113 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP):
62114 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
62115 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62116 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
62117 HYBRID_BREAK();
62118 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR):
62119 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
62120 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62121 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
62122 HYBRID_BREAK();
62123 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV):
62124 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
62125 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62126 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
62127 HYBRID_BREAK();
62128 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST):
62129 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
62130 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62131 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
62132 HYBRID_BREAK();
62133 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP):
62134 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
62135 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62136 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
62137 HYBRID_BREAK();
62138 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR):
62139 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
62140 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62141 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
62142 HYBRID_BREAK();
62143 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV):
62144 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
62145 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62146 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
62147 HYBRID_BREAK();
62148 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR):
62149 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
62150 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62151 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
62152 HYBRID_BREAK();
62153 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV):
62154 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
62155 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62156 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
62157 HYBRID_BREAK();
62158 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR):
62159 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
62160 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62161 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
62162 HYBRID_BREAK();
62163 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR):
62164 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
62165 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62166 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
62167 HYBRID_BREAK();
62168 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR):
62169 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
62170 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62171 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
62172 HYBRID_BREAK();
62173 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR):
62174 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
62175 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62176 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
62177 HYBRID_BREAK();
62178 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR):
62179 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
62180 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62181 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
62182 HYBRID_BREAK();
62183 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR):
62184 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
62185 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62186 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
62187 HYBRID_BREAK();
62188 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR):
62189 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
62190 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62191 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
62192 HYBRID_BREAK();
62193 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR):
62194 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
62195 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62196 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
62197 HYBRID_BREAK();
62198 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR):
62199 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
62200 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62201 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
62202 HYBRID_BREAK();
62203 HYBRID_CASE(ZEND_YIELD_SPEC_CV_TMPVAR):
62204 VM_TRACE(ZEND_YIELD_SPEC_CV_TMPVAR)
62205 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62206 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_TMPVAR)
62207 HYBRID_BREAK();
62208 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_TMP):
62209 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
62210 ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62211 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
62212 HYBRID_BREAK();
62213 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP):
62214 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
62215 ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62216 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
62217 HYBRID_BREAK();
62218 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED):
62219 VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
62220 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62221 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
62222 HYBRID_BREAK();
62223 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED):
62224 VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
62225 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62226 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
62227 HYBRID_BREAK();
62228 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_VAR):
62229 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
62230 ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62231 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
62232 HYBRID_BREAK();
62233 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR):
62234 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
62235 ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62236 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
62237 HYBRID_BREAK();
62238 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED):
62239 VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
62240 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62241 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
62242 HYBRID_BREAK();
62243 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED):
62244 VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
62245 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62246 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
62247 HYBRID_BREAK();
62248 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_VAR):
62249 VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_VAR)
62250 ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62251 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_VAR)
62252 HYBRID_BREAK();
62253 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_VAR):
62254 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_VAR)
62255 ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62256 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_VAR)
62257 HYBRID_BREAK();
62258 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED):
62259 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
62260 ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62261 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
62262 HYBRID_BREAK();
62263 HYBRID_CASE(ZEND_FETCH_R_SPEC_CV_UNUSED):
62264 VM_TRACE(ZEND_FETCH_R_SPEC_CV_UNUSED)
62265 ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62266 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CV_UNUSED)
62267 HYBRID_BREAK();
62268 HYBRID_CASE(ZEND_FETCH_W_SPEC_CV_UNUSED):
62269 VM_TRACE(ZEND_FETCH_W_SPEC_CV_UNUSED)
62270 ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62271 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CV_UNUSED)
62272 HYBRID_BREAK();
62273 HYBRID_CASE(ZEND_FETCH_RW_SPEC_CV_UNUSED):
62274 VM_TRACE(ZEND_FETCH_RW_SPEC_CV_UNUSED)
62275 ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62276 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CV_UNUSED)
62277 HYBRID_BREAK();
62278 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED):
62279 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
62280 ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62281 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
62282 HYBRID_BREAK();
62283 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED):
62284 VM_TRACE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
62285 ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62286 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
62287 HYBRID_BREAK();
62288 HYBRID_CASE(ZEND_FETCH_IS_SPEC_CV_UNUSED):
62289 VM_TRACE(ZEND_FETCH_IS_SPEC_CV_UNUSED)
62290 ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62291 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CV_UNUSED)
62292 HYBRID_BREAK();
62293 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED):
62294 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
62295 ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62296 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
62297 HYBRID_BREAK();
62298 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED):
62299 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
62300 ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62301 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
62302 HYBRID_BREAK();
62303 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED):
62304 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
62305 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62306 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
62307 HYBRID_BREAK();
62308 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST):
62309 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
62310 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62311 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
62312 HYBRID_BREAK();
62313 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP):
62314 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
62315 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62316 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
62317 HYBRID_BREAK();
62318 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR):
62319 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
62320 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62321 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
62322 HYBRID_BREAK();
62323 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV):
62324 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
62325 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62326 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
62327 HYBRID_BREAK();
62328 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED):
62329 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
62330 ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62331 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
62332 HYBRID_BREAK();
62333 HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_UNUSED):
62334 VM_TRACE(ZEND_SEND_VAR_SPEC_CV_UNUSED)
62335 ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62336 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_UNUSED)
62337 HYBRID_BREAK();
62338 HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_UNUSED):
62339 VM_TRACE(ZEND_SEND_REF_SPEC_CV_UNUSED)
62340 ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62341 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_UNUSED)
62342 HYBRID_BREAK();
62343 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED):
62344 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
62345 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62346 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
62347 HYBRID_BREAK();
62348 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK):
62349 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
62350 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62351 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
62352 HYBRID_BREAK();
62353 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED):
62354 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
62355 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62356 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
62357 HYBRID_BREAK();
62358 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED):
62359 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
62360 ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62361 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
62362 HYBRID_BREAK();
62363 HYBRID_CASE(ZEND_UNSET_CV_SPEC_CV_UNUSED):
62364 VM_TRACE(ZEND_UNSET_CV_SPEC_CV_UNUSED)
62365 ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62366 VM_TRACE_OP_END(ZEND_UNSET_CV_SPEC_CV_UNUSED)
62367 HYBRID_BREAK();
62368 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CV_UNUSED):
62369 VM_TRACE(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
62370 ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62371 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
62372 HYBRID_BREAK();
62373 HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET):
62374 VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
62375 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62376 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
62377 HYBRID_BREAK();
62378 HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY):
62379 VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
62380 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62381 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
62382 HYBRID_BREAK();
62383 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED):
62384 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
62385 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62386 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
62387 HYBRID_BREAK();
62388 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_UNUSED):
62389 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
62390 ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62391 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
62392 HYBRID_BREAK();
62393 HYBRID_CASE(ZEND_YIELD_SPEC_CV_UNUSED):
62394 VM_TRACE(ZEND_YIELD_SPEC_CV_UNUSED)
62395 ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62396 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_UNUSED)
62397 HYBRID_BREAK();
62398 HYBRID_CASE(ZEND_CHECK_VAR_SPEC_CV_UNUSED):
62399 VM_TRACE(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
62400 ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62401 VM_TRACE_OP_END(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
62402 HYBRID_BREAK();
62403 HYBRID_CASE(ZEND_MAKE_REF_SPEC_CV_UNUSED):
62404 VM_TRACE(ZEND_MAKE_REF_SPEC_CV_UNUSED)
62405 ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62406 VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_CV_UNUSED)
62407 HYBRID_BREAK();
62408 HYBRID_CASE(ZEND_COUNT_SPEC_CV_UNUSED):
62409 VM_TRACE(ZEND_COUNT_SPEC_CV_UNUSED)
62410 ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62411 VM_TRACE_OP_END(ZEND_COUNT_SPEC_CV_UNUSED)
62412 HYBRID_BREAK();
62413 HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED):
62414 VM_TRACE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
62415 ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62416 VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
62417 HYBRID_BREAK();
62418 HYBRID_CASE(ZEND_GET_CLASS_SPEC_CV_UNUSED):
62419 VM_TRACE(ZEND_GET_CLASS_SPEC_CV_UNUSED)
62420 ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62421 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CV_UNUSED)
62422 HYBRID_BREAK();
62423 HYBRID_CASE(ZEND_GET_TYPE_SPEC_CV_UNUSED):
62424 VM_TRACE(ZEND_GET_TYPE_SPEC_CV_UNUSED)
62425 ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62426 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CV_UNUSED)
62427 HYBRID_BREAK();
62428 HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED):
62429 VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
62430 ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62431 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
62432 HYBRID_BREAK();
62433 HYBRID_CASE(ZEND_DIV_SPEC_CV_CV):
62434 VM_TRACE(ZEND_DIV_SPEC_CV_CV)
62435 ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62436 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CV)
62437 HYBRID_BREAK();
62438 HYBRID_CASE(ZEND_POW_SPEC_CV_CV):
62439 VM_TRACE(ZEND_POW_SPEC_CV_CV)
62440 ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62441 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CV)
62442 HYBRID_BREAK();
62443 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CV):
62444 VM_TRACE(ZEND_CONCAT_SPEC_CV_CV)
62445 ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62446 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CV)
62447 HYBRID_BREAK();
62448 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CV):
62449 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CV)
62450 ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62451 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CV)
62452 HYBRID_BREAK();
62453 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV):
62454 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
62455 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62456 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
62457 HYBRID_BREAK();
62458 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV):
62459 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV)
62460 ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62461 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV)
62462 HYBRID_BREAK();
62463 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ):
62464 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
62465 ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62466 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
62467 HYBRID_BREAK();
62468 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ):
62469 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
62470 ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62471 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
62472 HYBRID_BREAK();
62473 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV):
62474 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
62475 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62476 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
62477 HYBRID_BREAK();
62478 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ):
62479 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
62480 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62481 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
62482 HYBRID_BREAK();
62483 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ):
62484 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
62485 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62486 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
62487 HYBRID_BREAK();
62488 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CV):
62489 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CV)
62490 ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62491 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CV)
62492 HYBRID_BREAK();
62493 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CV):
62494 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CV)
62495 ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62496 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CV)
62497 HYBRID_BREAK();
62498 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV):
62499 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
62500 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62501 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
62502 HYBRID_BREAK();
62503 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV):
62504 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
62505 ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62506 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
62507 HYBRID_BREAK();
62508 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CV):
62509 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CV)
62510 ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62511 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CV)
62512 HYBRID_BREAK();
62513 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CV):
62514 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
62515 ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62516 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
62517 HYBRID_BREAK();
62518 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CV):
62519 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CV)
62520 ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62521 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CV)
62522 HYBRID_BREAK();
62523 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CV):
62524 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CV)
62525 ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62526 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CV)
62527 HYBRID_BREAK();
62528 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CV):
62529 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CV)
62530 ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62531 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CV)
62532 HYBRID_BREAK();
62533 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CV):
62534 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
62535 ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62536 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
62537 HYBRID_BREAK();
62538 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CV):
62539 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
62540 ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62541 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
62542 HYBRID_BREAK();
62543 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV):
62544 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
62545 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62546 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
62547 HYBRID_BREAK();
62548 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV):
62549 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
62550 ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62551 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
62552 HYBRID_BREAK();
62553 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CV):
62554 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
62555 ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62556 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
62557 HYBRID_BREAK();
62558 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CV):
62559 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
62560 ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62561 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
62562 HYBRID_BREAK();
62563 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV):
62564 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
62565 ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62566 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
62567 HYBRID_BREAK();
62568 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV):
62569 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
62570 ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62571 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
62572 HYBRID_BREAK();
62573 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV):
62574 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
62575 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62576 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
62577 HYBRID_BREAK();
62578 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV):
62579 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
62580 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62581 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
62582 HYBRID_BREAK();
62583 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST):
62584 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
62585 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62586 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
62587 HYBRID_BREAK();
62588 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP):
62589 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
62590 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62591 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
62592 HYBRID_BREAK();
62593 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR):
62594 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
62595 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62596 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
62597 HYBRID_BREAK();
62598 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV):
62599 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
62600 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62601 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
62602 HYBRID_BREAK();
62603 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST):
62604 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
62605 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62606 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
62607 HYBRID_BREAK();
62608 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP):
62609 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
62610 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62611 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
62612 HYBRID_BREAK();
62613 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR):
62614 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
62615 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62616 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
62617 HYBRID_BREAK();
62618 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV):
62619 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
62620 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62621 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
62622 HYBRID_BREAK();
62623 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED):
62624 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
62625 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62626 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
62627 HYBRID_BREAK();
62628 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED):
62629 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
62630 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62631 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
62632 HYBRID_BREAK();
62633 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_CV):
62634 VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_CV)
62635 ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62636 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_CV)
62637 HYBRID_BREAK();
62638 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR):
62639 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
62640 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62641 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
62642 HYBRID_BREAK();
62643 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV):
62644 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
62645 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62646 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
62647 HYBRID_BREAK();
62648 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CV):
62649 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CV)
62650 ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62651 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CV)
62652 HYBRID_BREAK();
62653 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV):
62654 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
62655 ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62656 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
62657 HYBRID_BREAK();
62658 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV):
62659 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
62660 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62661 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
62662 HYBRID_BREAK();
62663 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CV):
62664 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CV)
62665 ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62666 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CV)
62667 HYBRID_BREAK();
62668 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CV):
62669 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CV)
62670 ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62671 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CV)
62672 HYBRID_BREAK();
62673 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CV):
62674 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CV)
62675 ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62676 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CV)
62677 HYBRID_BREAK();
62678 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV):
62679 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
62680 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62681 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
62682 HYBRID_BREAK();
62683 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV):
62684 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
62685 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62686 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
62687 HYBRID_BREAK();
62688 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV):
62689 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
62690 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62691 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
62692 HYBRID_BREAK();
62693 HYBRID_CASE(ZEND_YIELD_SPEC_CV_CV):
62694 VM_TRACE(ZEND_YIELD_SPEC_CV_CV)
62695 ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62696 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CV)
62697 HYBRID_BREAK();
62698 HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV):
62699 VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
62700 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62701 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
62702 HYBRID_BREAK();
62703 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV):
62704 VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
62705 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62706 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
62707 HYBRID_BREAK();
62708 HYBRID_CASE(HYBRID_HALT):
62709 #ifdef ZEND_VM_FP_GLOBAL_REG
62710 execute_data = vm_stack_data.orig_execute_data;
62711 #endif
62712 #ifdef ZEND_VM_IP_GLOBAL_REG
62713 opline = vm_stack_data.orig_opline;
62714 #endif
62715 return;
62716 HYBRID_DEFAULT:
62717 VM_TRACE(ZEND_NULL)
62718 ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62719 VM_TRACE_OP_END(ZEND_NULL)
62720 HYBRID_BREAK(); /* Never reached */
62721 #else
62722 #ifdef ZEND_VM_FP_GLOBAL_REG
62723 execute_data = vm_stack_data.orig_execute_data;
62724 # ifdef ZEND_VM_IP_GLOBAL_REG
62725 opline = vm_stack_data.orig_opline;
62726 # endif
62727 return;
62728 #else
62729 if (EXPECTED(ret > 0)) {
62730 execute_data = EG(current_execute_data);
62731 ZEND_VM_LOOP_INTERRUPT_CHECK();
62732 } else {
62733 # ifdef ZEND_VM_IP_GLOBAL_REG
62734 opline = vm_stack_data.orig_opline;
62735 # endif
62736 return;
62737 }
62738 #endif
62739 #endif
62740 }
62741
62742 }
62743 zend_error_noreturn(E_CORE_ERROR, "Arrived at end of main loop which shouldn't happen");
62744 }
62745 #if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
62746 # pragma GCC pop_options
62747 #endif
62748
62749 ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value)
62750 {
62751 zend_execute_data *execute_data;
62752 void *object_or_called_scope;
62753 uint32_t call_info;
62754
62755 if (EG(exception) != NULL) {
62756 return;
62757 }
62758
62759 object_or_called_scope = zend_get_this_object(EG(current_execute_data));
62760 if (EXPECTED(!object_or_called_scope)) {
62761 object_or_called_scope = zend_get_called_scope(EG(current_execute_data));
62762 call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE;
62763 } else {
62764 call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE | ZEND_CALL_HAS_THIS;
62765 }
62766 execute_data = zend_vm_stack_push_call_frame(call_info,
62767 (zend_function*)op_array, 0, object_or_called_scope);
62768 if (EG(current_execute_data)) {
62769 execute_data->symbol_table = zend_rebuild_symbol_table();
62770 } else {
62771 execute_data->symbol_table = &EG(symbol_table);
62772 }
62773 EX(prev_execute_data) = EG(current_execute_data);
62774 i_init_code_execute_data(execute_data, op_array, return_value);
62775 ZEND_OBSERVER_FCALL_BEGIN(execute_data);
62776 zend_execute_ex(execute_data);
62777 /* Observer end handlers are called from ZEND_RETURN */
62778 zend_vm_stack_free_call_frame(execute_data);
62779 }
62780
62781
62782 void zend_vm_init(void)
62783 {
62784 static const void * const labels[] = {
62785 ZEND_NOP_SPEC_HANDLER,
62786 ZEND_ADD_SPEC_CONST_CONST_HANDLER,
62787 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
62788 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
62789 ZEND_NULL_HANDLER,
62790 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
62791 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
62792 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62793 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62794 ZEND_NULL_HANDLER,
62795 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62796 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
62797 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62798 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62799 ZEND_NULL_HANDLER,
62800 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62801 ZEND_NULL_HANDLER,
62802 ZEND_NULL_HANDLER,
62803 ZEND_NULL_HANDLER,
62804 ZEND_NULL_HANDLER,
62805 ZEND_NULL_HANDLER,
62806 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
62807 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62808 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62809 ZEND_NULL_HANDLER,
62810 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62811 ZEND_SUB_SPEC_CONST_CONST_HANDLER,
62812 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
62813 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
62814 ZEND_NULL_HANDLER,
62815 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
62816 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
62817 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62818 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62819 ZEND_NULL_HANDLER,
62820 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62821 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
62822 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62823 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62824 ZEND_NULL_HANDLER,
62825 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62826 ZEND_NULL_HANDLER,
62827 ZEND_NULL_HANDLER,
62828 ZEND_NULL_HANDLER,
62829 ZEND_NULL_HANDLER,
62830 ZEND_NULL_HANDLER,
62831 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
62832 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62833 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62834 ZEND_NULL_HANDLER,
62835 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62836 ZEND_MUL_SPEC_CONST_CONST_HANDLER,
62837 ZEND_NULL_HANDLER,
62838 ZEND_NULL_HANDLER,
62839 ZEND_NULL_HANDLER,
62840 ZEND_NULL_HANDLER,
62841 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
62842 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62843 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62844 ZEND_NULL_HANDLER,
62845 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62846 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
62847 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62848 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62849 ZEND_NULL_HANDLER,
62850 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62851 ZEND_NULL_HANDLER,
62852 ZEND_NULL_HANDLER,
62853 ZEND_NULL_HANDLER,
62854 ZEND_NULL_HANDLER,
62855 ZEND_NULL_HANDLER,
62856 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
62857 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62858 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62859 ZEND_NULL_HANDLER,
62860 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62861 ZEND_DIV_SPEC_CONST_CONST_HANDLER,
62862 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
62863 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
62864 ZEND_NULL_HANDLER,
62865 ZEND_DIV_SPEC_CONST_CV_HANDLER,
62866 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
62867 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
62868 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
62869 ZEND_NULL_HANDLER,
62870 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
62871 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
62872 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
62873 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
62874 ZEND_NULL_HANDLER,
62875 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
62876 ZEND_NULL_HANDLER,
62877 ZEND_NULL_HANDLER,
62878 ZEND_NULL_HANDLER,
62879 ZEND_NULL_HANDLER,
62880 ZEND_NULL_HANDLER,
62881 ZEND_DIV_SPEC_CV_CONST_HANDLER,
62882 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
62883 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
62884 ZEND_NULL_HANDLER,
62885 ZEND_DIV_SPEC_CV_CV_HANDLER,
62886 ZEND_MOD_SPEC_CONST_CONST_HANDLER,
62887 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
62888 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
62889 ZEND_NULL_HANDLER,
62890 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
62891 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
62892 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62893 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62894 ZEND_NULL_HANDLER,
62895 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62896 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
62897 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62898 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62899 ZEND_NULL_HANDLER,
62900 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62901 ZEND_NULL_HANDLER,
62902 ZEND_NULL_HANDLER,
62903 ZEND_NULL_HANDLER,
62904 ZEND_NULL_HANDLER,
62905 ZEND_NULL_HANDLER,
62906 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
62907 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62908 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62909 ZEND_NULL_HANDLER,
62910 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62911 ZEND_SL_SPEC_CONST_CONST_HANDLER,
62912 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
62913 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
62914 ZEND_NULL_HANDLER,
62915 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
62916 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
62917 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62918 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62919 ZEND_NULL_HANDLER,
62920 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62921 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
62922 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62923 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62924 ZEND_NULL_HANDLER,
62925 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62926 ZEND_NULL_HANDLER,
62927 ZEND_NULL_HANDLER,
62928 ZEND_NULL_HANDLER,
62929 ZEND_NULL_HANDLER,
62930 ZEND_NULL_HANDLER,
62931 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
62932 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62933 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62934 ZEND_NULL_HANDLER,
62935 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62936 ZEND_SR_SPEC_CONST_CONST_HANDLER,
62937 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
62938 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
62939 ZEND_NULL_HANDLER,
62940 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
62941 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
62942 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62943 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62944 ZEND_NULL_HANDLER,
62945 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62946 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
62947 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62948 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62949 ZEND_NULL_HANDLER,
62950 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62951 ZEND_NULL_HANDLER,
62952 ZEND_NULL_HANDLER,
62953 ZEND_NULL_HANDLER,
62954 ZEND_NULL_HANDLER,
62955 ZEND_NULL_HANDLER,
62956 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
62957 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62958 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62959 ZEND_NULL_HANDLER,
62960 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62961 ZEND_NULL_HANDLER,
62962 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
62963 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
62964 ZEND_NULL_HANDLER,
62965 ZEND_CONCAT_SPEC_CONST_CV_HANDLER,
62966 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
62967 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
62968 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
62969 ZEND_NULL_HANDLER,
62970 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
62971 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
62972 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
62973 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
62974 ZEND_NULL_HANDLER,
62975 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
62976 ZEND_NULL_HANDLER,
62977 ZEND_NULL_HANDLER,
62978 ZEND_NULL_HANDLER,
62979 ZEND_NULL_HANDLER,
62980 ZEND_NULL_HANDLER,
62981 ZEND_CONCAT_SPEC_CV_CONST_HANDLER,
62982 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
62983 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
62984 ZEND_NULL_HANDLER,
62985 ZEND_CONCAT_SPEC_CV_CV_HANDLER,
62986 ZEND_BW_OR_SPEC_CONST_CONST_HANDLER,
62987 ZEND_NULL_HANDLER,
62988 ZEND_NULL_HANDLER,
62989 ZEND_NULL_HANDLER,
62990 ZEND_NULL_HANDLER,
62991 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
62992 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62993 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62994 ZEND_NULL_HANDLER,
62995 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62996 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
62997 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62998 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62999 ZEND_NULL_HANDLER,
63000 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63001 ZEND_NULL_HANDLER,
63002 ZEND_NULL_HANDLER,
63003 ZEND_NULL_HANDLER,
63004 ZEND_NULL_HANDLER,
63005 ZEND_NULL_HANDLER,
63006 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
63007 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63008 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63009 ZEND_NULL_HANDLER,
63010 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63011 ZEND_BW_AND_SPEC_CONST_CONST_HANDLER,
63012 ZEND_NULL_HANDLER,
63013 ZEND_NULL_HANDLER,
63014 ZEND_NULL_HANDLER,
63015 ZEND_NULL_HANDLER,
63016 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
63017 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63018 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63019 ZEND_NULL_HANDLER,
63020 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63021 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
63022 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63023 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63024 ZEND_NULL_HANDLER,
63025 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63026 ZEND_NULL_HANDLER,
63027 ZEND_NULL_HANDLER,
63028 ZEND_NULL_HANDLER,
63029 ZEND_NULL_HANDLER,
63030 ZEND_NULL_HANDLER,
63031 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
63032 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63033 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63034 ZEND_NULL_HANDLER,
63035 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63036 ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER,
63037 ZEND_NULL_HANDLER,
63038 ZEND_NULL_HANDLER,
63039 ZEND_NULL_HANDLER,
63040 ZEND_NULL_HANDLER,
63041 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
63042 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63043 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63044 ZEND_NULL_HANDLER,
63045 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63046 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
63047 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63048 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63049 ZEND_NULL_HANDLER,
63050 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63051 ZEND_NULL_HANDLER,
63052 ZEND_NULL_HANDLER,
63053 ZEND_NULL_HANDLER,
63054 ZEND_NULL_HANDLER,
63055 ZEND_NULL_HANDLER,
63056 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
63057 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63058 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63059 ZEND_NULL_HANDLER,
63060 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63061 ZEND_POW_SPEC_CONST_CONST_HANDLER,
63062 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
63063 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
63064 ZEND_NULL_HANDLER,
63065 ZEND_POW_SPEC_CONST_CV_HANDLER,
63066 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
63067 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
63068 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
63069 ZEND_NULL_HANDLER,
63070 ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
63071 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
63072 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
63073 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
63074 ZEND_NULL_HANDLER,
63075 ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
63076 ZEND_NULL_HANDLER,
63077 ZEND_NULL_HANDLER,
63078 ZEND_NULL_HANDLER,
63079 ZEND_NULL_HANDLER,
63080 ZEND_NULL_HANDLER,
63081 ZEND_POW_SPEC_CV_CONST_HANDLER,
63082 ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
63083 ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
63084 ZEND_NULL_HANDLER,
63085 ZEND_POW_SPEC_CV_CV_HANDLER,
63086 ZEND_BW_NOT_SPEC_CONST_HANDLER,
63087 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
63088 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
63089 ZEND_NULL_HANDLER,
63090 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
63091 ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
63092 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
63093 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
63094 ZEND_NULL_HANDLER,
63095 ZEND_BOOL_NOT_SPEC_CV_HANDLER,
63096 ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER,
63097 ZEND_NULL_HANDLER,
63098 ZEND_NULL_HANDLER,
63099 ZEND_NULL_HANDLER,
63100 ZEND_NULL_HANDLER,
63101 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
63102 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
63103 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
63104 ZEND_NULL_HANDLER,
63105 ZEND_NULL_HANDLER,
63106 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
63107 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
63108 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
63109 ZEND_NULL_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_BOOL_XOR_SPEC_CV_CONST_HANDLER,
63117 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
63118 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
63119 ZEND_NULL_HANDLER,
63120 ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER,
63121 ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER,
63122 ZEND_NULL_HANDLER,
63123 ZEND_NULL_HANDLER,
63124 ZEND_NULL_HANDLER,
63125 ZEND_NULL_HANDLER,
63126 ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER,
63127 ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER,
63128 ZEND_NULL_HANDLER,
63129 ZEND_NULL_HANDLER,
63130 ZEND_NULL_HANDLER,
63131 ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER,
63132 ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER,
63133 ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER,
63134 ZEND_NULL_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_IS_IDENTICAL_SPEC_CV_CONST_HANDLER,
63142 ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER,
63143 ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER,
63144 ZEND_NULL_HANDLER,
63145 ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER,
63146 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER,
63147 ZEND_NULL_HANDLER,
63148 ZEND_NULL_HANDLER,
63149 ZEND_NULL_HANDLER,
63150 ZEND_NULL_HANDLER,
63151 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER,
63152 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER,
63153 ZEND_NULL_HANDLER,
63154 ZEND_NULL_HANDLER,
63155 ZEND_NULL_HANDLER,
63156 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER,
63157 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER,
63158 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER,
63159 ZEND_NULL_HANDLER,
63160 ZEND_NULL_HANDLER,
63161 ZEND_NULL_HANDLER,
63162 ZEND_NULL_HANDLER,
63163 ZEND_NULL_HANDLER,
63164 ZEND_NULL_HANDLER,
63165 ZEND_NULL_HANDLER,
63166 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER,
63167 ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER,
63168 ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER,
63169 ZEND_NULL_HANDLER,
63170 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER,
63171 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
63172 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
63173 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
63174 ZEND_NULL_HANDLER,
63175 ZEND_NULL_HANDLER,
63176 ZEND_NULL_HANDLER,
63177 ZEND_NULL_HANDLER,
63178 ZEND_NULL_HANDLER,
63179 ZEND_NULL_HANDLER,
63180 ZEND_NULL_HANDLER,
63181 ZEND_NULL_HANDLER,
63182 ZEND_NULL_HANDLER,
63183 ZEND_NULL_HANDLER,
63184 ZEND_NULL_HANDLER,
63185 ZEND_NULL_HANDLER,
63186 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
63187 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
63188 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
63189 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63190 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63191 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63192 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63193 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63194 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
63202 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
63203 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
63204 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63205 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63206 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63207 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63208 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63209 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63210 ZEND_NULL_HANDLER,
63211 ZEND_NULL_HANDLER,
63212 ZEND_NULL_HANDLER,
63213 ZEND_NULL_HANDLER,
63214 ZEND_NULL_HANDLER,
63215 ZEND_NULL_HANDLER,
63216 ZEND_NULL_HANDLER,
63217 ZEND_NULL_HANDLER,
63218 ZEND_NULL_HANDLER,
63219 ZEND_NULL_HANDLER,
63220 ZEND_NULL_HANDLER,
63221 ZEND_NULL_HANDLER,
63222 ZEND_NULL_HANDLER,
63223 ZEND_NULL_HANDLER,
63224 ZEND_NULL_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_IS_EQUAL_SPEC_CV_CONST_HANDLER,
63232 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
63233 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
63234 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
63235 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
63236 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
63237 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
63238 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
63239 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
63240 ZEND_NULL_HANDLER,
63241 ZEND_NULL_HANDLER,
63242 ZEND_NULL_HANDLER,
63243 ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER,
63244 ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
63245 ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
63246 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
63247 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
63248 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
63249 ZEND_NULL_HANDLER,
63250 ZEND_NULL_HANDLER,
63251 ZEND_NULL_HANDLER,
63252 ZEND_NULL_HANDLER,
63253 ZEND_NULL_HANDLER,
63254 ZEND_NULL_HANDLER,
63255 ZEND_NULL_HANDLER,
63256 ZEND_NULL_HANDLER,
63257 ZEND_NULL_HANDLER,
63258 ZEND_NULL_HANDLER,
63259 ZEND_NULL_HANDLER,
63260 ZEND_NULL_HANDLER,
63261 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
63262 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
63263 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
63264 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63265 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63266 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63267 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63268 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63269 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
63277 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
63278 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
63279 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63280 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63281 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63282 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63283 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63284 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63285 ZEND_NULL_HANDLER,
63286 ZEND_NULL_HANDLER,
63287 ZEND_NULL_HANDLER,
63288 ZEND_NULL_HANDLER,
63289 ZEND_NULL_HANDLER,
63290 ZEND_NULL_HANDLER,
63291 ZEND_NULL_HANDLER,
63292 ZEND_NULL_HANDLER,
63293 ZEND_NULL_HANDLER,
63294 ZEND_NULL_HANDLER,
63295 ZEND_NULL_HANDLER,
63296 ZEND_NULL_HANDLER,
63297 ZEND_NULL_HANDLER,
63298 ZEND_NULL_HANDLER,
63299 ZEND_NULL_HANDLER,
63300 ZEND_NULL_HANDLER,
63301 ZEND_NULL_HANDLER,
63302 ZEND_NULL_HANDLER,
63303 ZEND_NULL_HANDLER,
63304 ZEND_NULL_HANDLER,
63305 ZEND_NULL_HANDLER,
63306 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER,
63307 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
63308 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
63309 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
63310 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
63311 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
63312 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
63313 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
63314 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
63315 ZEND_NULL_HANDLER,
63316 ZEND_NULL_HANDLER,
63317 ZEND_NULL_HANDLER,
63318 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
63319 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
63320 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
63321 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
63322 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
63323 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
63324 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
63325 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63326 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63327 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
63328 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63329 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63330 ZEND_NULL_HANDLER,
63331 ZEND_NULL_HANDLER,
63332 ZEND_NULL_HANDLER,
63333 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
63334 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63335 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63336 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
63337 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63338 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_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_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63343 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63344 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63345 ZEND_NULL_HANDLER,
63346 ZEND_NULL_HANDLER,
63347 ZEND_NULL_HANDLER,
63348 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63349 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63350 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63351 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
63352 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63353 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
63354 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63355 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63356 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63357 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63358 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63359 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63360 ZEND_NULL_HANDLER,
63361 ZEND_NULL_HANDLER,
63362 ZEND_NULL_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_NULL_HANDLER,
63370 ZEND_NULL_HANDLER,
63371 ZEND_NULL_HANDLER,
63372 ZEND_NULL_HANDLER,
63373 ZEND_NULL_HANDLER,
63374 ZEND_NULL_HANDLER,
63375 ZEND_NULL_HANDLER,
63376 ZEND_NULL_HANDLER,
63377 ZEND_NULL_HANDLER,
63378 ZEND_NULL_HANDLER,
63379 ZEND_NULL_HANDLER,
63380 ZEND_NULL_HANDLER,
63381 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
63382 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63383 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
63384 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63385 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63386 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63387 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63388 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63389 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63390 ZEND_NULL_HANDLER,
63391 ZEND_NULL_HANDLER,
63392 ZEND_NULL_HANDLER,
63393 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63394 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63395 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63396 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
63397 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
63398 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
63399 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
63400 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63401 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63402 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
63403 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63404 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63405 ZEND_NULL_HANDLER,
63406 ZEND_NULL_HANDLER,
63407 ZEND_NULL_HANDLER,
63408 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
63409 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63410 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63411 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
63412 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63413 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_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_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63418 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63419 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63420 ZEND_NULL_HANDLER,
63421 ZEND_NULL_HANDLER,
63422 ZEND_NULL_HANDLER,
63423 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63424 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63425 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63426 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
63427 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63428 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
63429 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63430 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63431 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63432 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63433 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63434 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63435 ZEND_NULL_HANDLER,
63436 ZEND_NULL_HANDLER,
63437 ZEND_NULL_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_NULL_HANDLER,
63445 ZEND_NULL_HANDLER,
63446 ZEND_NULL_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_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
63457 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63458 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
63459 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63460 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63461 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63462 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63463 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63464 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63465 ZEND_NULL_HANDLER,
63466 ZEND_NULL_HANDLER,
63467 ZEND_NULL_HANDLER,
63468 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63469 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63470 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63471 ZEND_NULL_HANDLER,
63472 ZEND_NULL_HANDLER,
63473 ZEND_NULL_HANDLER,
63474 ZEND_NULL_HANDLER,
63475 ZEND_NULL_HANDLER,
63476 ZEND_NULL_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_NULL_HANDLER,
63488 ZEND_NULL_HANDLER,
63489 ZEND_NULL_HANDLER,
63490 ZEND_NULL_HANDLER,
63491 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER,
63492 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER,
63493 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER,
63494 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER,
63495 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER,
63496 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER,
63497 ZEND_NULL_HANDLER,
63498 ZEND_NULL_HANDLER,
63499 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
63500 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_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_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER,
63512 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER,
63513 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER,
63514 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER,
63515 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER,
63516 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER,
63517 ZEND_NULL_HANDLER,
63518 ZEND_NULL_HANDLER,
63519 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER,
63520 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_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_NULL_HANDLER,
63548 ZEND_NULL_HANDLER,
63549 ZEND_NULL_HANDLER,
63550 ZEND_NULL_HANDLER,
63551 ZEND_NULL_HANDLER,
63552 ZEND_NULL_HANDLER,
63553 ZEND_NULL_HANDLER,
63554 ZEND_NULL_HANDLER,
63555 ZEND_NULL_HANDLER,
63556 ZEND_NULL_HANDLER,
63557 ZEND_NULL_HANDLER,
63558 ZEND_NULL_HANDLER,
63559 ZEND_NULL_HANDLER,
63560 ZEND_NULL_HANDLER,
63561 ZEND_NULL_HANDLER,
63562 ZEND_NULL_HANDLER,
63563 ZEND_NULL_HANDLER,
63564 ZEND_NULL_HANDLER,
63565 ZEND_NULL_HANDLER,
63566 ZEND_NULL_HANDLER,
63567 ZEND_NULL_HANDLER,
63568 ZEND_NULL_HANDLER,
63569 ZEND_NULL_HANDLER,
63570 ZEND_NULL_HANDLER,
63571 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
63572 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
63573 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
63574 ZEND_NULL_HANDLER,
63575 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
63576 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
63577 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
63578 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63579 ZEND_NULL_HANDLER,
63580 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63581 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
63582 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
63583 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63584 ZEND_NULL_HANDLER,
63585 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63586 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER,
63587 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER,
63588 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER,
63589 ZEND_NULL_HANDLER,
63590 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER,
63591 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
63592 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
63593 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
63594 ZEND_NULL_HANDLER,
63595 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
63596 ZEND_NULL_HANDLER,
63597 ZEND_NULL_HANDLER,
63598 ZEND_NULL_HANDLER,
63599 ZEND_NULL_HANDLER,
63600 ZEND_NULL_HANDLER,
63601 ZEND_NULL_HANDLER,
63602 ZEND_NULL_HANDLER,
63603 ZEND_NULL_HANDLER,
63604 ZEND_NULL_HANDLER,
63605 ZEND_NULL_HANDLER,
63606 ZEND_NULL_HANDLER,
63607 ZEND_NULL_HANDLER,
63608 ZEND_NULL_HANDLER,
63609 ZEND_NULL_HANDLER,
63610 ZEND_NULL_HANDLER,
63611 ZEND_NULL_HANDLER,
63612 ZEND_NULL_HANDLER,
63613 ZEND_NULL_HANDLER,
63614 ZEND_NULL_HANDLER,
63615 ZEND_NULL_HANDLER,
63616 ZEND_NULL_HANDLER,
63617 ZEND_NULL_HANDLER,
63618 ZEND_NULL_HANDLER,
63619 ZEND_NULL_HANDLER,
63620 ZEND_NULL_HANDLER,
63621 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
63622 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
63623 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
63624 ZEND_NULL_HANDLER,
63625 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
63626 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
63627 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
63628 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63629 ZEND_NULL_HANDLER,
63630 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63631 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
63632 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
63633 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63634 ZEND_NULL_HANDLER,
63635 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63636 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER,
63637 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER,
63638 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER,
63639 ZEND_NULL_HANDLER,
63640 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER,
63641 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
63642 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
63643 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
63644 ZEND_NULL_HANDLER,
63645 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_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_NULL_HANDLER,
63673 ZEND_NULL_HANDLER,
63674 ZEND_NULL_HANDLER,
63675 ZEND_NULL_HANDLER,
63676 ZEND_NULL_HANDLER,
63677 ZEND_NULL_HANDLER,
63678 ZEND_NULL_HANDLER,
63679 ZEND_NULL_HANDLER,
63680 ZEND_NULL_HANDLER,
63681 ZEND_NULL_HANDLER,
63682 ZEND_NULL_HANDLER,
63683 ZEND_NULL_HANDLER,
63684 ZEND_NULL_HANDLER,
63685 ZEND_NULL_HANDLER,
63686 ZEND_NULL_HANDLER,
63687 ZEND_NULL_HANDLER,
63688 ZEND_NULL_HANDLER,
63689 ZEND_NULL_HANDLER,
63690 ZEND_NULL_HANDLER,
63691 ZEND_NULL_HANDLER,
63692 ZEND_NULL_HANDLER,
63693 ZEND_NULL_HANDLER,
63694 ZEND_NULL_HANDLER,
63695 ZEND_NULL_HANDLER,
63696 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
63697 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
63698 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
63699 ZEND_NULL_HANDLER,
63700 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
63701 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
63702 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
63703 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63704 ZEND_NULL_HANDLER,
63705 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63706 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
63707 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
63708 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63709 ZEND_NULL_HANDLER,
63710 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63711 ZEND_NULL_HANDLER,
63712 ZEND_NULL_HANDLER,
63713 ZEND_NULL_HANDLER,
63714 ZEND_NULL_HANDLER,
63715 ZEND_NULL_HANDLER,
63716 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
63717 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
63718 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
63719 ZEND_NULL_HANDLER,
63720 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
63721 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER,
63722 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER,
63723 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
63724 ZEND_NULL_HANDLER,
63725 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
63726 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
63727 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
63728 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
63729 ZEND_NULL_HANDLER,
63730 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
63731 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
63732 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
63733 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
63734 ZEND_NULL_HANDLER,
63735 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
63736 ZEND_NULL_HANDLER,
63737 ZEND_NULL_HANDLER,
63738 ZEND_NULL_HANDLER,
63739 ZEND_NULL_HANDLER,
63740 ZEND_NULL_HANDLER,
63741 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER,
63742 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER,
63743 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
63744 ZEND_NULL_HANDLER,
63745 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
63746 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
63747 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
63748 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
63749 ZEND_NULL_HANDLER,
63750 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
63751 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
63752 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
63753 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63754 ZEND_NULL_HANDLER,
63755 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63756 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
63757 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
63758 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63759 ZEND_NULL_HANDLER,
63760 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63761 ZEND_NULL_HANDLER,
63762 ZEND_NULL_HANDLER,
63763 ZEND_NULL_HANDLER,
63764 ZEND_NULL_HANDLER,
63765 ZEND_NULL_HANDLER,
63766 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
63767 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
63768 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
63769 ZEND_NULL_HANDLER,
63770 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER,
63771 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER,
63772 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER,
63773 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER,
63774 ZEND_NULL_HANDLER,
63775 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER,
63776 ZEND_NULL_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_ASSIGN_OP_SPEC_VAR_CONST_HANDLER,
63787 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
63788 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
63789 ZEND_NULL_HANDLER,
63790 ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER,
63791 ZEND_NULL_HANDLER,
63792 ZEND_NULL_HANDLER,
63793 ZEND_NULL_HANDLER,
63794 ZEND_NULL_HANDLER,
63795 ZEND_NULL_HANDLER,
63796 ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER,
63797 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
63798 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
63799 ZEND_NULL_HANDLER,
63800 ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER,
63801 ZEND_NULL_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_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER,
63812 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
63813 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
63814 ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER,
63815 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER,
63816 ZEND_NULL_HANDLER,
63817 ZEND_NULL_HANDLER,
63818 ZEND_NULL_HANDLER,
63819 ZEND_NULL_HANDLER,
63820 ZEND_NULL_HANDLER,
63821 ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER,
63822 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
63823 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
63824 ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER,
63825 ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER,
63826 ZEND_NULL_HANDLER,
63827 ZEND_NULL_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_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER,
63837 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
63838 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
63839 ZEND_NULL_HANDLER,
63840 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER,
63841 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER,
63842 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
63843 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
63844 ZEND_NULL_HANDLER,
63845 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER,
63846 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER,
63847 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
63848 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
63849 ZEND_NULL_HANDLER,
63850 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER,
63851 ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER,
63852 ZEND_NULL_HANDLER,
63853 ZEND_NULL_HANDLER,
63854 ZEND_NULL_HANDLER,
63855 ZEND_NULL_HANDLER,
63856 ZEND_NULL_HANDLER,
63857 ZEND_NULL_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_ASSIGN_REF_SPEC_VAR_VAR_HANDLER,
63865 ZEND_NULL_HANDLER,
63866 ZEND_ASSIGN_REF_SPEC_VAR_CV_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_ASSIGN_REF_SPEC_CV_VAR_HANDLER,
63875 ZEND_NULL_HANDLER,
63876 ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER,
63877 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
63878 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
63879 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
63880 ZEND_NULL_HANDLER,
63881 ZEND_QM_ASSIGN_SPEC_CV_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_NULL_HANDLER,
63911 ZEND_NULL_HANDLER,
63912 ZEND_NULL_HANDLER,
63913 ZEND_NULL_HANDLER,
63914 ZEND_NULL_HANDLER,
63915 ZEND_NULL_HANDLER,
63916 ZEND_NULL_HANDLER,
63917 ZEND_NULL_HANDLER,
63918 ZEND_NULL_HANDLER,
63919 ZEND_NULL_HANDLER,
63920 ZEND_NULL_HANDLER,
63921 ZEND_NULL_HANDLER,
63922 ZEND_NULL_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_NULL_HANDLER,
63931 ZEND_NULL_HANDLER,
63932 ZEND_NULL_HANDLER,
63933 ZEND_NULL_HANDLER,
63934 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
63935 ZEND_NULL_HANDLER,
63936 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
63937 ZEND_NULL_HANDLER,
63938 ZEND_NULL_HANDLER,
63939 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63940 ZEND_NULL_HANDLER,
63941 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63942 ZEND_NULL_HANDLER,
63943 ZEND_NULL_HANDLER,
63944 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63945 ZEND_NULL_HANDLER,
63946 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63947 ZEND_NULL_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_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
63955 ZEND_NULL_HANDLER,
63956 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
63957 ZEND_NULL_HANDLER,
63958 ZEND_NULL_HANDLER,
63959 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
63960 ZEND_NULL_HANDLER,
63961 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
63962 ZEND_NULL_HANDLER,
63963 ZEND_NULL_HANDLER,
63964 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
63965 ZEND_NULL_HANDLER,
63966 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
63967 ZEND_NULL_HANDLER,
63968 ZEND_NULL_HANDLER,
63969 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
63970 ZEND_NULL_HANDLER,
63971 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
63972 ZEND_NULL_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_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
63980 ZEND_NULL_HANDLER,
63981 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
63982 ZEND_NULL_HANDLER,
63983 ZEND_NULL_HANDLER,
63984 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
63985 ZEND_NULL_HANDLER,
63986 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
63987 ZEND_NULL_HANDLER,
63988 ZEND_NULL_HANDLER,
63989 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63990 ZEND_NULL_HANDLER,
63991 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63992 ZEND_NULL_HANDLER,
63993 ZEND_NULL_HANDLER,
63994 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63995 ZEND_NULL_HANDLER,
63996 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63997 ZEND_NULL_HANDLER,
63998 ZEND_NULL_HANDLER,
63999 ZEND_NULL_HANDLER,
64000 ZEND_NULL_HANDLER,
64001 ZEND_NULL_HANDLER,
64002 ZEND_NULL_HANDLER,
64003 ZEND_NULL_HANDLER,
64004 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
64005 ZEND_NULL_HANDLER,
64006 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER,
64007 ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER,
64008 ZEND_NULL_HANDLER,
64009 ZEND_NULL_HANDLER,
64010 ZEND_NULL_HANDLER,
64011 ZEND_NULL_HANDLER,
64012 ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
64013 ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER,
64014 ZEND_NULL_HANDLER,
64015 ZEND_NULL_HANDLER,
64016 ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER,
64017 ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER,
64018 ZEND_NULL_HANDLER,
64019 ZEND_NULL_HANDLER,
64020 ZEND_NULL_HANDLER,
64021 ZEND_NULL_HANDLER,
64022 ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
64023 ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER,
64024 ZEND_NULL_HANDLER,
64025 ZEND_NULL_HANDLER,
64026 ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER,
64027 ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER,
64028 ZEND_NULL_HANDLER,
64029 ZEND_NULL_HANDLER,
64030 ZEND_POST_INC_SPEC_VAR_HANDLER,
64031 ZEND_NULL_HANDLER,
64032 ZEND_POST_INC_SPEC_CV_HANDLER,
64033 ZEND_NULL_HANDLER,
64034 ZEND_NULL_HANDLER,
64035 ZEND_POST_DEC_SPEC_VAR_HANDLER,
64036 ZEND_NULL_HANDLER,
64037 ZEND_POST_DEC_SPEC_CV_HANDLER,
64038 ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER,
64039 ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER,
64040 ZEND_JMP_SPEC_HANDLER,
64041 ZEND_JMPZ_SPEC_CONST_HANDLER,
64042 ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
64043 ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
64044 ZEND_NULL_HANDLER,
64045 ZEND_JMPZ_SPEC_CV_HANDLER,
64046 ZEND_JMPNZ_SPEC_CONST_HANDLER,
64047 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
64048 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
64049 ZEND_NULL_HANDLER,
64050 ZEND_JMPNZ_SPEC_CV_HANDLER,
64051 ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
64052 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
64053 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
64054 ZEND_NULL_HANDLER,
64055 ZEND_JMPZ_EX_SPEC_CV_HANDLER,
64056 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
64057 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
64058 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
64059 ZEND_NULL_HANDLER,
64060 ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
64061 ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER,
64062 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
64063 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
64064 ZEND_NULL_HANDLER,
64065 ZEND_CASE_SPEC_TMPVAR_CV_HANDLER,
64066 ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER,
64067 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
64068 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
64069 ZEND_NULL_HANDLER,
64070 ZEND_NULL_HANDLER,
64071 ZEND_NULL_HANDLER,
64072 ZEND_NULL_HANDLER,
64073 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER,
64074 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
64075 ZEND_NULL_HANDLER,
64076 ZEND_NULL_HANDLER,
64077 ZEND_CAST_SPEC_CONST_HANDLER,
64078 ZEND_CAST_SPEC_TMP_HANDLER,
64079 ZEND_CAST_SPEC_VAR_HANDLER,
64080 ZEND_NULL_HANDLER,
64081 ZEND_CAST_SPEC_CV_HANDLER,
64082 ZEND_BOOL_SPEC_CONST_HANDLER,
64083 ZEND_BOOL_SPEC_TMPVAR_HANDLER,
64084 ZEND_BOOL_SPEC_TMPVAR_HANDLER,
64085 ZEND_NULL_HANDLER,
64086 ZEND_BOOL_SPEC_CV_HANDLER,
64087 ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER,
64088 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64089 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64090 ZEND_NULL_HANDLER,
64091 ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER,
64092 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64093 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64094 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64095 ZEND_NULL_HANDLER,
64096 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64097 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64098 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64099 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64100 ZEND_NULL_HANDLER,
64101 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64102 ZEND_NULL_HANDLER,
64103 ZEND_NULL_HANDLER,
64104 ZEND_NULL_HANDLER,
64105 ZEND_NULL_HANDLER,
64106 ZEND_NULL_HANDLER,
64107 ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER,
64108 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64109 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64110 ZEND_NULL_HANDLER,
64111 ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER,
64112 ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER,
64113 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
64114 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
64115 ZEND_NULL_HANDLER,
64116 ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER,
64117 ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER,
64118 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
64119 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
64120 ZEND_NULL_HANDLER,
64121 ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER,
64122 ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER,
64123 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
64124 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
64125 ZEND_NULL_HANDLER,
64126 ZEND_ROPE_END_SPEC_TMP_CV_HANDLER,
64127 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
64128 ZEND_END_SILENCE_SPEC_TMP_HANDLER,
64129 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
64130 ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER,
64131 ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER,
64132 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
64133 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
64134 ZEND_INIT_FCALL_SPEC_CONST_HANDLER,
64135 ZEND_RETURN_SPEC_CONST_HANDLER,
64136 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
64137 ZEND_RETURN_SPEC_TMP_HANDLER,
64138 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
64139 ZEND_RETURN_SPEC_VAR_HANDLER,
64140 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
64141 ZEND_NULL_HANDLER,
64142 ZEND_NULL_HANDLER,
64143 ZEND_RETURN_SPEC_CV_HANDLER,
64144 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
64145 ZEND_RECV_SPEC_UNUSED_HANDLER,
64146 ZEND_RECV_INIT_SPEC_CONST_HANDLER,
64147 ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER,
64148 ZEND_NULL_HANDLER,
64149 ZEND_NULL_HANDLER,
64150 ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER,
64151 ZEND_NULL_HANDLER,
64152 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
64153 ZEND_NULL_HANDLER,
64154 ZEND_NULL_HANDLER,
64155 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER,
64156 ZEND_NULL_HANDLER,
64157 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
64158 ZEND_NULL_HANDLER,
64159 ZEND_NULL_HANDLER,
64160 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_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_NULL_HANDLER,
64169 ZEND_NULL_HANDLER,
64170 ZEND_NULL_HANDLER,
64171 ZEND_NULL_HANDLER,
64172 ZEND_NULL_HANDLER,
64173 ZEND_NULL_HANDLER,
64174 ZEND_NULL_HANDLER,
64175 ZEND_NULL_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_NULL_HANDLER,
64189 ZEND_NULL_HANDLER,
64190 ZEND_NULL_HANDLER,
64191 ZEND_NULL_HANDLER,
64192 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
64193 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
64194 ZEND_NULL_HANDLER,
64195 ZEND_NULL_HANDLER,
64196 ZEND_NULL_HANDLER,
64197 ZEND_NULL_HANDLER,
64198 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER,
64199 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_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_NULL_HANDLER,
64209 ZEND_NULL_HANDLER,
64210 ZEND_NULL_HANDLER,
64211 ZEND_NULL_HANDLER,
64212 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
64213 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
64214 ZEND_NULL_HANDLER,
64215 ZEND_NULL_HANDLER,
64216 ZEND_NULL_HANDLER,
64217 ZEND_NULL_HANDLER,
64218 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER,
64219 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER,
64220 ZEND_NULL_HANDLER,
64221 ZEND_NULL_HANDLER,
64222 ZEND_NULL_HANDLER,
64223 ZEND_NULL_HANDLER,
64224 ZEND_NULL_HANDLER,
64225 ZEND_NULL_HANDLER,
64226 ZEND_NULL_HANDLER,
64227 ZEND_NULL_HANDLER,
64228 ZEND_NULL_HANDLER,
64229 ZEND_NULL_HANDLER,
64230 ZEND_NULL_HANDLER,
64231 ZEND_NULL_HANDLER,
64232 ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER,
64233 ZEND_NULL_HANDLER,
64234 ZEND_NULL_HANDLER,
64235 ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER,
64236 ZEND_NULL_HANDLER,
64237 ZEND_NULL_HANDLER,
64238 ZEND_NULL_HANDLER,
64239 ZEND_NULL_HANDLER,
64240 ZEND_NULL_HANDLER,
64241 ZEND_NULL_HANDLER,
64242 ZEND_SEND_REF_SPEC_CV_CONST_HANDLER,
64243 ZEND_NULL_HANDLER,
64244 ZEND_NULL_HANDLER,
64245 ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER,
64246 ZEND_NULL_HANDLER,
64247 ZEND_NEW_SPEC_CONST_UNUSED_HANDLER,
64248 ZEND_NULL_HANDLER,
64249 ZEND_NEW_SPEC_VAR_UNUSED_HANDLER,
64250 ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER,
64251 ZEND_NULL_HANDLER,
64252 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
64253 ZEND_FREE_SPEC_TMPVAR_HANDLER,
64254 ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER,
64255 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
64256 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
64257 ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER,
64258 ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER,
64259 ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER,
64260 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
64261 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
64262 ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER,
64263 ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER,
64264 ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER,
64265 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
64266 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
64267 ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
64268 ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
64269 ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
64270 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
64271 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
64272 ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
64273 ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
64274 ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
64275 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
64276 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
64277 ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER,
64278 ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER,
64279 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER,
64280 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
64281 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
64282 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER,
64283 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER,
64284 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER,
64285 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
64286 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
64287 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER,
64288 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER,
64289 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER,
64290 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
64291 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
64292 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
64293 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
64294 ZEND_NULL_HANDLER,
64295 ZEND_NULL_HANDLER,
64296 ZEND_NULL_HANDLER,
64297 ZEND_NULL_HANDLER,
64298 ZEND_NULL_HANDLER,
64299 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
64300 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
64301 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
64302 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
64303 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
64304 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
64305 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
64306 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
64307 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
64308 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
64309 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
64310 ZEND_NULL_HANDLER,
64311 ZEND_NULL_HANDLER,
64312 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
64313 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
64314 ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER,
64315 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
64316 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
64317 ZEND_NULL_HANDLER,
64318 ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER,
64319 ZEND_NULL_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_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
64330 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
64331 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
64332 ZEND_NULL_HANDLER,
64333 ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER,
64334 ZEND_NULL_HANDLER,
64335 ZEND_NULL_HANDLER,
64336 ZEND_NULL_HANDLER,
64337 ZEND_NULL_HANDLER,
64338 ZEND_NULL_HANDLER,
64339 ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER,
64340 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
64341 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
64342 ZEND_NULL_HANDLER,
64343 ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER,
64344 ZEND_NULL_HANDLER,
64345 ZEND_NULL_HANDLER,
64346 ZEND_NULL_HANDLER,
64347 ZEND_NULL_HANDLER,
64348 ZEND_NULL_HANDLER,
64349 ZEND_NULL_HANDLER,
64350 ZEND_NULL_HANDLER,
64351 ZEND_NULL_HANDLER,
64352 ZEND_NULL_HANDLER,
64353 ZEND_NULL_HANDLER,
64354 ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER,
64355 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
64356 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
64357 ZEND_NULL_HANDLER,
64358 ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER,
64359 ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER,
64360 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
64361 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
64362 ZEND_NULL_HANDLER,
64363 ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER,
64364 ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER,
64365 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
64366 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
64367 ZEND_NULL_HANDLER,
64368 ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER,
64369 ZEND_FE_RESET_R_SPEC_CONST_HANDLER,
64370 ZEND_FE_RESET_R_SPEC_TMP_HANDLER,
64371 ZEND_FE_RESET_R_SPEC_VAR_HANDLER,
64372 ZEND_NULL_HANDLER,
64373 ZEND_FE_RESET_R_SPEC_CV_HANDLER,
64374 ZEND_FE_FETCH_R_SPEC_VAR_HANDLER,
64375 ZEND_EXIT_SPEC_HANDLER,
64376 ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER,
64377 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
64378 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
64379 ZEND_NULL_HANDLER,
64380 ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER,
64381 ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER,
64382 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
64383 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
64384 ZEND_NULL_HANDLER,
64385 ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER,
64386 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
64387 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64388 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64389 ZEND_NULL_HANDLER,
64390 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
64391 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
64392 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64393 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64394 ZEND_NULL_HANDLER,
64395 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
64396 ZEND_NULL_HANDLER,
64397 ZEND_NULL_HANDLER,
64398 ZEND_NULL_HANDLER,
64399 ZEND_NULL_HANDLER,
64400 ZEND_NULL_HANDLER,
64401 ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
64402 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
64403 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
64404 ZEND_NULL_HANDLER,
64405 ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
64406 ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER,
64407 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
64408 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
64409 ZEND_NULL_HANDLER,
64410 ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER,
64411 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
64412 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64413 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64414 ZEND_NULL_HANDLER,
64415 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
64416 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
64417 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64418 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64419 ZEND_NULL_HANDLER,
64420 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
64421 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER,
64422 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
64423 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
64424 ZEND_NULL_HANDLER,
64425 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER,
64426 ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER,
64427 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
64428 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
64429 ZEND_NULL_HANDLER,
64430 ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
64431 ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER,
64432 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
64433 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
64434 ZEND_NULL_HANDLER,
64435 ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER,
64436 ZEND_NULL_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_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
64447 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
64448 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
64449 ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
64450 ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
64451 ZEND_NULL_HANDLER,
64452 ZEND_NULL_HANDLER,
64453 ZEND_NULL_HANDLER,
64454 ZEND_NULL_HANDLER,
64455 ZEND_NULL_HANDLER,
64456 ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
64457 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
64458 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
64459 ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
64460 ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
64461 ZEND_NULL_HANDLER,
64462 ZEND_NULL_HANDLER,
64463 ZEND_NULL_HANDLER,
64464 ZEND_NULL_HANDLER,
64465 ZEND_NULL_HANDLER,
64466 ZEND_NULL_HANDLER,
64467 ZEND_NULL_HANDLER,
64468 ZEND_NULL_HANDLER,
64469 ZEND_NULL_HANDLER,
64470 ZEND_NULL_HANDLER,
64471 ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER,
64472 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
64473 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
64474 ZEND_NULL_HANDLER,
64475 ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER,
64476 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER,
64477 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
64478 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
64479 ZEND_NULL_HANDLER,
64480 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER,
64481 ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER,
64482 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
64483 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
64484 ZEND_NULL_HANDLER,
64485 ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
64486 ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER,
64487 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
64488 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
64489 ZEND_NULL_HANDLER,
64490 ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER,
64491 ZEND_NULL_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_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
64502 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
64503 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
64504 ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
64505 ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
64506 ZEND_NULL_HANDLER,
64507 ZEND_NULL_HANDLER,
64508 ZEND_NULL_HANDLER,
64509 ZEND_NULL_HANDLER,
64510 ZEND_NULL_HANDLER,
64511 ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
64512 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
64513 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
64514 ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
64515 ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
64516 ZEND_NULL_HANDLER,
64517 ZEND_NULL_HANDLER,
64518 ZEND_NULL_HANDLER,
64519 ZEND_NULL_HANDLER,
64520 ZEND_NULL_HANDLER,
64521 ZEND_NULL_HANDLER,
64522 ZEND_NULL_HANDLER,
64523 ZEND_NULL_HANDLER,
64524 ZEND_NULL_HANDLER,
64525 ZEND_NULL_HANDLER,
64526 ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER,
64527 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
64528 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
64529 ZEND_NULL_HANDLER,
64530 ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER,
64531 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER,
64532 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
64533 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
64534 ZEND_NULL_HANDLER,
64535 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER,
64536 ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER,
64537 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
64538 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
64539 ZEND_NULL_HANDLER,
64540 ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
64541 ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER,
64542 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
64543 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
64544 ZEND_NULL_HANDLER,
64545 ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
64546 ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER,
64547 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
64548 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
64549 ZEND_NULL_HANDLER,
64550 ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER,
64551 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
64552 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64553 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64554 ZEND_NULL_HANDLER,
64555 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
64556 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
64557 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64558 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64559 ZEND_NULL_HANDLER,
64560 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
64561 ZEND_NULL_HANDLER,
64562 ZEND_NULL_HANDLER,
64563 ZEND_NULL_HANDLER,
64564 ZEND_NULL_HANDLER,
64565 ZEND_NULL_HANDLER,
64566 ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
64567 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
64568 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
64569 ZEND_NULL_HANDLER,
64570 ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
64571 ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER,
64572 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
64573 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
64574 ZEND_NULL_HANDLER,
64575 ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER,
64576 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
64577 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64578 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64579 ZEND_NULL_HANDLER,
64580 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
64581 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
64582 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64583 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64584 ZEND_NULL_HANDLER,
64585 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
64586 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER,
64587 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
64588 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
64589 ZEND_NULL_HANDLER,
64590 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER,
64591 ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER,
64592 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
64593 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
64594 ZEND_NULL_HANDLER,
64595 ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
64596 ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
64597 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
64598 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
64599 ZEND_NULL_HANDLER,
64600 ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
64601 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
64602 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
64603 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
64604 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
64605 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER,
64606 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
64607 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
64608 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
64609 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
64610 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER,
64611 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
64612 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
64613 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
64614 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
64615 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
64616 ZEND_NULL_HANDLER,
64617 ZEND_NULL_HANDLER,
64618 ZEND_NULL_HANDLER,
64619 ZEND_NULL_HANDLER,
64620 ZEND_NULL_HANDLER,
64621 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
64622 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
64623 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
64624 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
64625 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
64626 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
64627 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
64628 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
64629 ZEND_NULL_HANDLER,
64630 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER,
64631 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
64632 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
64633 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
64634 ZEND_NULL_HANDLER,
64635 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER,
64636 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
64637 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
64638 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
64639 ZEND_NULL_HANDLER,
64640 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER,
64641 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
64642 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
64643 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
64644 ZEND_NULL_HANDLER,
64645 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER,
64646 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER,
64647 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
64648 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
64649 ZEND_NULL_HANDLER,
64650 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
64651 ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER,
64652 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
64653 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
64654 ZEND_NULL_HANDLER,
64655 ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER,
64656 ZEND_NULL_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_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
64667 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
64668 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
64669 ZEND_NULL_HANDLER,
64670 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
64671 ZEND_NULL_HANDLER,
64672 ZEND_NULL_HANDLER,
64673 ZEND_NULL_HANDLER,
64674 ZEND_NULL_HANDLER,
64675 ZEND_NULL_HANDLER,
64676 ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
64677 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
64678 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
64679 ZEND_NULL_HANDLER,
64680 ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
64681 ZEND_NULL_HANDLER,
64682 ZEND_NULL_HANDLER,
64683 ZEND_NULL_HANDLER,
64684 ZEND_NULL_HANDLER,
64685 ZEND_NULL_HANDLER,
64686 ZEND_NULL_HANDLER,
64687 ZEND_NULL_HANDLER,
64688 ZEND_NULL_HANDLER,
64689 ZEND_NULL_HANDLER,
64690 ZEND_NULL_HANDLER,
64691 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER,
64692 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
64693 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
64694 ZEND_NULL_HANDLER,
64695 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER,
64696 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER,
64697 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
64698 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
64699 ZEND_NULL_HANDLER,
64700 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER,
64701 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER,
64702 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
64703 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
64704 ZEND_NULL_HANDLER,
64705 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER,
64706 ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER,
64707 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
64708 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
64709 ZEND_NULL_HANDLER,
64710 ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER,
64711 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
64712 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64713 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64714 ZEND_NULL_HANDLER,
64715 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
64716 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
64717 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64718 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64719 ZEND_NULL_HANDLER,
64720 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
64721 ZEND_NULL_HANDLER,
64722 ZEND_NULL_HANDLER,
64723 ZEND_NULL_HANDLER,
64724 ZEND_NULL_HANDLER,
64725 ZEND_NULL_HANDLER,
64726 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
64727 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64728 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64729 ZEND_NULL_HANDLER,
64730 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
64731 ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
64732 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
64733 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
64734 ZEND_NULL_HANDLER,
64735 ZEND_NULL_HANDLER,
64736 ZEND_NULL_HANDLER,
64737 ZEND_NULL_HANDLER,
64738 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER,
64739 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER,
64740 ZEND_NULL_HANDLER,
64741 ZEND_NULL_HANDLER,
64742 ZEND_EXT_STMT_SPEC_HANDLER,
64743 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
64744 ZEND_EXT_FCALL_END_SPEC_HANDLER,
64745 ZEND_EXT_NOP_SPEC_HANDLER,
64746 ZEND_TICKS_SPEC_HANDLER,
64747 ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER,
64748 ZEND_NULL_HANDLER,
64749 ZEND_NULL_HANDLER,
64750 ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER,
64751 ZEND_NULL_HANDLER,
64752 ZEND_CATCH_SPEC_CONST_HANDLER,
64753 ZEND_THROW_SPEC_CONST_HANDLER,
64754 ZEND_THROW_SPEC_TMPVAR_HANDLER,
64755 ZEND_THROW_SPEC_TMPVAR_HANDLER,
64756 ZEND_NULL_HANDLER,
64757 ZEND_THROW_SPEC_CV_HANDLER,
64758 ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER,
64759 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
64760 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
64761 ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
64762 ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER,
64763 ZEND_CLONE_SPEC_CONST_HANDLER,
64764 ZEND_CLONE_SPEC_TMPVAR_HANDLER,
64765 ZEND_CLONE_SPEC_TMPVAR_HANDLER,
64766 ZEND_CLONE_SPEC_UNUSED_HANDLER,
64767 ZEND_CLONE_SPEC_CV_HANDLER,
64768 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
64769 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
64770 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
64771 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
64772 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
64773 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
64774 ZEND_NULL_HANDLER,
64775 ZEND_NULL_HANDLER,
64776 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
64777 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
64778 ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
64779 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
64780 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
64781 ZEND_NULL_HANDLER,
64782 ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER,
64783 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
64784 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
64785 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
64786 ZEND_NULL_HANDLER,
64787 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
64788 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
64789 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
64790 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
64791 ZEND_NULL_HANDLER,
64792 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
64793 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
64794 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
64795 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
64796 ZEND_NULL_HANDLER,
64797 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
64798 ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER,
64799 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
64800 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
64801 ZEND_NULL_HANDLER,
64802 ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER,
64803 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
64804 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
64805 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
64806 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER,
64807 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER,
64808 ZEND_NULL_HANDLER,
64809 ZEND_NULL_HANDLER,
64810 ZEND_NULL_HANDLER,
64811 ZEND_NULL_HANDLER,
64812 ZEND_NULL_HANDLER,
64813 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
64814 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
64815 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
64816 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER,
64817 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER,
64818 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
64819 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
64820 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
64821 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER,
64822 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
64823 ZEND_NULL_HANDLER,
64824 ZEND_NULL_HANDLER,
64825 ZEND_NULL_HANDLER,
64826 ZEND_NULL_HANDLER,
64827 ZEND_NULL_HANDLER,
64828 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER,
64829 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
64830 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
64831 ZEND_NULL_HANDLER,
64832 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER,
64833 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER,
64834 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
64835 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
64836 ZEND_NULL_HANDLER,
64837 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER,
64838 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
64839 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
64840 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
64841 ZEND_NULL_HANDLER,
64842 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
64843 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
64844 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
64845 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
64846 ZEND_NULL_HANDLER,
64847 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
64848 ZEND_NULL_HANDLER,
64849 ZEND_NULL_HANDLER,
64850 ZEND_NULL_HANDLER,
64851 ZEND_NULL_HANDLER,
64852 ZEND_NULL_HANDLER,
64853 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER,
64854 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
64855 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
64856 ZEND_NULL_HANDLER,
64857 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER,
64858 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
64859 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
64860 ZEND_NULL_HANDLER,
64861 ZEND_NULL_HANDLER,
64862 ZEND_NULL_HANDLER,
64863 ZEND_NULL_HANDLER,
64864 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER,
64865 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER,
64866 ZEND_NULL_HANDLER,
64867 ZEND_NULL_HANDLER,
64868 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
64869 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
64870 ZEND_NULL_HANDLER,
64871 ZEND_NULL_HANDLER,
64872 ZEND_NULL_HANDLER,
64873 ZEND_NULL_HANDLER,
64874 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER,
64875 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_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_NULL_HANDLER,
64895 ZEND_NULL_HANDLER,
64896 ZEND_NULL_HANDLER,
64897 ZEND_NULL_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_NULL_HANDLER,
64905 ZEND_NULL_HANDLER,
64906 ZEND_NULL_HANDLER,
64907 ZEND_NULL_HANDLER,
64908 ZEND_NULL_HANDLER,
64909 ZEND_NULL_HANDLER,
64910 ZEND_NULL_HANDLER,
64911 ZEND_NULL_HANDLER,
64912 ZEND_NULL_HANDLER,
64913 ZEND_NULL_HANDLER,
64914 ZEND_NULL_HANDLER,
64915 ZEND_NULL_HANDLER,
64916 ZEND_NULL_HANDLER,
64917 ZEND_NULL_HANDLER,
64918 ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER,
64919 ZEND_NULL_HANDLER,
64920 ZEND_NULL_HANDLER,
64921 ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER,
64922 ZEND_NULL_HANDLER,
64923 ZEND_NULL_HANDLER,
64924 ZEND_NULL_HANDLER,
64925 ZEND_NULL_HANDLER,
64926 ZEND_NULL_HANDLER,
64927 ZEND_NULL_HANDLER,
64928 ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER,
64929 ZEND_NULL_HANDLER,
64930 ZEND_NULL_HANDLER,
64931 ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER,
64932 ZEND_NULL_HANDLER,
64933 ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER,
64934 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
64935 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
64936 ZEND_NULL_HANDLER,
64937 ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER,
64938 ZEND_SEND_ARRAY_SPEC_HANDLER,
64939 ZEND_SEND_USER_SPEC_CONST_HANDLER,
64940 ZEND_SEND_USER_SPEC_TMP_HANDLER,
64941 ZEND_SEND_USER_SPEC_VAR_HANDLER,
64942 ZEND_NULL_HANDLER,
64943 ZEND_SEND_USER_SPEC_CV_HANDLER,
64944 ZEND_STRLEN_SPEC_CONST_HANDLER,
64945 ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
64946 ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
64947 ZEND_NULL_HANDLER,
64948 ZEND_STRLEN_SPEC_CV_HANDLER,
64949 ZEND_DEFINED_SPEC_CONST_HANDLER,
64950 ZEND_TYPE_CHECK_SPEC_CONST_HANDLER,
64951 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
64952 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
64953 ZEND_NULL_HANDLER,
64954 ZEND_TYPE_CHECK_SPEC_CV_HANDLER,
64955 ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER,
64956 ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER,
64957 ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER,
64958 ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
64959 ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER,
64960 ZEND_FE_RESET_RW_SPEC_CONST_HANDLER,
64961 ZEND_FE_RESET_RW_SPEC_TMP_HANDLER,
64962 ZEND_FE_RESET_RW_SPEC_VAR_HANDLER,
64963 ZEND_NULL_HANDLER,
64964 ZEND_FE_RESET_RW_SPEC_CV_HANDLER,
64965 ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER,
64966 ZEND_FE_FREE_SPEC_TMPVAR_HANDLER,
64967 ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER,
64968 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
64969 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
64970 ZEND_NULL_HANDLER,
64971 ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER,
64972 ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER,
64973 ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER,
64974 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
64975 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
64976 ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER,
64977 ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER,
64978 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
64979 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
64980 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER,
64981 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER,
64982 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
64983 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
64984 ZEND_NULL_HANDLER,
64985 ZEND_NULL_HANDLER,
64986 ZEND_NULL_HANDLER,
64987 ZEND_NULL_HANDLER,
64988 ZEND_NULL_HANDLER,
64989 ZEND_NULL_HANDLER,
64990 ZEND_NULL_HANDLER,
64991 ZEND_NULL_HANDLER,
64992 ZEND_NULL_HANDLER,
64993 ZEND_NULL_HANDLER,
64994 ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER,
64995 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
64996 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
64997 ZEND_NULL_HANDLER,
64998 ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER,
64999 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
65000 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65001 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65002 ZEND_NULL_HANDLER,
65003 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
65004 ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER,
65005 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
65006 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
65007 ZEND_NULL_HANDLER,
65008 ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER,
65009 ZEND_NULL_HANDLER,
65010 ZEND_NULL_HANDLER,
65011 ZEND_NULL_HANDLER,
65012 ZEND_NULL_HANDLER,
65013 ZEND_NULL_HANDLER,
65014 ZEND_NULL_HANDLER,
65015 ZEND_NULL_HANDLER,
65016 ZEND_NULL_HANDLER,
65017 ZEND_NULL_HANDLER,
65018 ZEND_NULL_HANDLER,
65019 ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER,
65020 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
65021 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
65022 ZEND_NULL_HANDLER,
65023 ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER,
65024 ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
65025 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65026 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65027 ZEND_NULL_HANDLER,
65028 ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
65029 ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER,
65030 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
65031 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
65032 ZEND_NULL_HANDLER,
65033 ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER,
65034 ZEND_ECHO_SPEC_CONST_HANDLER,
65035 ZEND_ECHO_SPEC_TMPVAR_HANDLER,
65036 ZEND_ECHO_SPEC_TMPVAR_HANDLER,
65037 ZEND_NULL_HANDLER,
65038 ZEND_ECHO_SPEC_CV_HANDLER,
65039 ZEND_NULL_HANDLER,
65040 ZEND_NULL_HANDLER,
65041 ZEND_NULL_HANDLER,
65042 ZEND_NULL_HANDLER,
65043 ZEND_NULL_HANDLER,
65044 ZEND_NULL_HANDLER,
65045 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
65046 ZEND_NULL_HANDLER,
65047 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
65048 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
65049 ZEND_NULL_HANDLER,
65050 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
65051 ZEND_NULL_HANDLER,
65052 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
65053 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
65054 ZEND_NULL_HANDLER,
65055 ZEND_NULL_HANDLER,
65056 ZEND_NULL_HANDLER,
65057 ZEND_NULL_HANDLER,
65058 ZEND_NULL_HANDLER,
65059 ZEND_NULL_HANDLER,
65060 ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER,
65061 ZEND_NULL_HANDLER,
65062 ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER,
65063 ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER,
65064 ZEND_NULL_HANDLER,
65065 ZEND_GENERATOR_CREATE_SPEC_HANDLER,
65066 ZEND_NULL_HANDLER,
65067 ZEND_NULL_HANDLER,
65068 ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER,
65069 ZEND_NULL_HANDLER,
65070 ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER,
65071 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
65072 ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER,
65073 ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER,
65074 ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER,
65075 ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER,
65076 ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER,
65077 ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER,
65078 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER,
65079 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
65080 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
65081 ZEND_NULL_HANDLER,
65082 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER,
65083 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
65084 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
65085 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
65086 ZEND_NULL_HANDLER,
65087 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
65088 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
65089 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
65090 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
65091 ZEND_NULL_HANDLER,
65092 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
65093 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER,
65094 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65095 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65096 ZEND_NULL_HANDLER,
65097 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER,
65098 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER,
65099 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
65100 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
65101 ZEND_NULL_HANDLER,
65102 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
65103 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
65104 ZEND_USER_OPCODE_SPEC_HANDLER,
65105 ZEND_ASSERT_CHECK_SPEC_HANDLER,
65106 ZEND_JMP_SET_SPEC_CONST_HANDLER,
65107 ZEND_JMP_SET_SPEC_TMP_HANDLER,
65108 ZEND_JMP_SET_SPEC_VAR_HANDLER,
65109 ZEND_NULL_HANDLER,
65110 ZEND_JMP_SET_SPEC_CV_HANDLER,
65111 ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER,
65112 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER,
65113 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER,
65114 ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER,
65115 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
65116 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
65117 ZEND_NULL_HANDLER,
65118 ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER,
65119 ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER,
65120 ZEND_NULL_HANDLER,
65121 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
65122 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
65123 ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER,
65124 ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER,
65125 ZEND_CALL_TRAMPOLINE_SPEC_HANDLER,
65126 ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER,
65127 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
65128 ZEND_YIELD_SPEC_CONST_CONST_HANDLER,
65129 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
65130 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
65131 ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER,
65132 ZEND_YIELD_SPEC_CONST_CV_HANDLER,
65133 ZEND_YIELD_SPEC_TMP_CONST_HANDLER,
65134 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
65135 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
65136 ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER,
65137 ZEND_YIELD_SPEC_TMP_CV_HANDLER,
65138 ZEND_YIELD_SPEC_VAR_CONST_HANDLER,
65139 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
65140 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
65141 ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER,
65142 ZEND_YIELD_SPEC_VAR_CV_HANDLER,
65143 ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER,
65144 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
65145 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
65146 ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER,
65147 ZEND_YIELD_SPEC_UNUSED_CV_HANDLER,
65148 ZEND_YIELD_SPEC_CV_CONST_HANDLER,
65149 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
65150 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
65151 ZEND_YIELD_SPEC_CV_UNUSED_HANDLER,
65152 ZEND_YIELD_SPEC_CV_CV_HANDLER,
65153 ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER,
65154 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
65155 ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER,
65156 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
65157 ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER,
65158 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
65159 ZEND_NULL_HANDLER,
65160 ZEND_NULL_HANDLER,
65161 ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER,
65162 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
65163 ZEND_FAST_CALL_SPEC_HANDLER,
65164 ZEND_FAST_RET_SPEC_HANDLER,
65165 ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER,
65166 ZEND_SEND_UNPACK_SPEC_HANDLER,
65167 ZEND_YIELD_FROM_SPEC_CONST_HANDLER,
65168 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
65169 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
65170 ZEND_NULL_HANDLER,
65171 ZEND_YIELD_FROM_SPEC_CV_HANDLER,
65172 ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER,
65173 ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER,
65174 ZEND_COALESCE_SPEC_CONST_HANDLER,
65175 ZEND_COALESCE_SPEC_TMP_HANDLER,
65176 ZEND_COALESCE_SPEC_VAR_HANDLER,
65177 ZEND_NULL_HANDLER,
65178 ZEND_COALESCE_SPEC_CV_HANDLER,
65179 ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER,
65180 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
65181 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
65182 ZEND_NULL_HANDLER,
65183 ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER,
65184 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
65185 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
65186 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
65187 ZEND_NULL_HANDLER,
65188 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
65189 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
65190 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
65191 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
65192 ZEND_NULL_HANDLER,
65193 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
65194 ZEND_NULL_HANDLER,
65195 ZEND_NULL_HANDLER,
65196 ZEND_NULL_HANDLER,
65197 ZEND_NULL_HANDLER,
65198 ZEND_NULL_HANDLER,
65199 ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER,
65200 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
65201 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
65202 ZEND_NULL_HANDLER,
65203 ZEND_SPACESHIP_SPEC_CV_CV_HANDLER,
65204 ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
65205 ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER,
65206 ZEND_NULL_HANDLER,
65207 ZEND_NULL_HANDLER,
65208 ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
65209 ZEND_NULL_HANDLER,
65210 ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER,
65211 ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER,
65212 ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER,
65213 ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER,
65214 ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER,
65215 ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER,
65216 ZEND_UNSET_STATIC_PROP_SPEC_HANDLER,
65217 ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER,
65218 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER,
65219 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
65220 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
65221 ZEND_NULL_HANDLER,
65222 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
65223 ZEND_NULL_HANDLER,
65224 ZEND_NULL_HANDLER,
65225 ZEND_NULL_HANDLER,
65226 ZEND_NULL_HANDLER,
65227 ZEND_NULL_HANDLER,
65228 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER,
65229 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
65230 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
65231 ZEND_NULL_HANDLER,
65232 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
65233 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
65234 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
65235 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
65236 ZEND_NULL_HANDLER,
65237 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
65238 ZEND_NULL_HANDLER,
65239 ZEND_NULL_HANDLER,
65240 ZEND_NULL_HANDLER,
65241 ZEND_NULL_HANDLER,
65242 ZEND_NULL_HANDLER,
65243 ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER,
65244 ZEND_BIND_STATIC_SPEC_CV_HANDLER,
65245 ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER,
65246 ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
65247 ZEND_NULL_HANDLER,
65248 ZEND_NULL_HANDLER,
65249 ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
65250 ZEND_NULL_HANDLER,
65251 ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER,
65252 ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER,
65253 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65254 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65255 ZEND_NULL_HANDLER,
65256 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65257 ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER,
65258 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
65259 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
65260 ZEND_NULL_HANDLER,
65261 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
65262 ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER,
65263 ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER,
65264 ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER,
65265 ZEND_NULL_HANDLER,
65266 ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER,
65267 ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER,
65268 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
65269 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
65270 ZEND_NULL_HANDLER,
65271 ZEND_COUNT_SPEC_CV_UNUSED_HANDLER,
65272 ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER,
65273 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
65274 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
65275 ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
65276 ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER,
65277 ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
65278 ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER,
65279 ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER,
65280 ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER,
65281 ZEND_NULL_HANDLER,
65282 ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER,
65283 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER,
65284 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
65285 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
65286 ZEND_NULL_HANDLER,
65287 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER,
65288 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
65289 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
65290 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
65291 ZEND_NULL_HANDLER,
65292 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
65293 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
65294 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
65295 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
65296 ZEND_NULL_HANDLER,
65297 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
65298 ZEND_NULL_HANDLER,
65299 ZEND_NULL_HANDLER,
65300 ZEND_NULL_HANDLER,
65301 ZEND_NULL_HANDLER,
65302 ZEND_NULL_HANDLER,
65303 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER,
65304 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
65305 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
65306 ZEND_NULL_HANDLER,
65307 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER,
65308 ZEND_MATCH_SPEC_CONST_CONST_HANDLER,
65309 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
65310 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
65311 ZEND_NULL_HANDLER,
65312 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
65313 ZEND_NULL_HANDLER,
65314 ZEND_NULL_HANDLER,
65315 ZEND_NULL_HANDLER,
65316 ZEND_NULL_HANDLER,
65317 ZEND_NULL_HANDLER,
65318 ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER,
65319 ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER,
65320 ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER,
65321 ZEND_NULL_HANDLER,
65322 ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER,
65323 ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER,
65324 ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER,
65325 ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER,
65326 ZEND_NULL_HANDLER,
65327 ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER,
65328 ZEND_NULL_HANDLER,
65329 ZEND_NULL_HANDLER,
65330 ZEND_NULL_HANDLER,
65331 ZEND_NULL_HANDLER,
65332 ZEND_NULL_HANDLER,
65333 ZEND_NULL_HANDLER,
65334 ZEND_NULL_HANDLER,
65335 ZEND_NULL_HANDLER,
65336 ZEND_NULL_HANDLER,
65337 ZEND_NULL_HANDLER,
65338 ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER,
65339 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
65340 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
65341 ZEND_NULL_HANDLER,
65342 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
65343 ZEND_JMP_NULL_SPEC_CONST_HANDLER,
65344 ZEND_JMP_NULL_SPEC_TMP_HANDLER,
65345 ZEND_JMP_NULL_SPEC_VAR_HANDLER,
65346 ZEND_NULL_HANDLER,
65347 ZEND_JMP_NULL_SPEC_CV_HANDLER,
65348 ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
65349 ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER,
65350 ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
65351 ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER,
65352 ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER,
65353 ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER,
65354 ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER,
65355 ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER,
65356 ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER,
65357 ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER,
65358 ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER,
65359 ZEND_RECV_NOTYPE_SPEC_HANDLER,
65360 ZEND_NULL_HANDLER,
65361 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
65362 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
65363 ZEND_NULL_HANDLER,
65364 ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER,
65365 ZEND_JMP_FORWARD_SPEC_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_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65372 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65373 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65374 ZEND_NULL_HANDLER,
65375 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65376 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65377 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65378 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65379 ZEND_NULL_HANDLER,
65380 ZEND_ADD_LONG_NO_OVERFLOW_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_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65387 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65388 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65389 ZEND_NULL_HANDLER,
65390 ZEND_ADD_LONG_NO_OVERFLOW_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_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65397 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65398 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65399 ZEND_NULL_HANDLER,
65400 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65401 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65402 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65403 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65404 ZEND_NULL_HANDLER,
65405 ZEND_ADD_LONG_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_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65412 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65413 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65414 ZEND_NULL_HANDLER,
65415 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65416 ZEND_NULL_HANDLER,
65417 ZEND_NULL_HANDLER,
65418 ZEND_NULL_HANDLER,
65419 ZEND_NULL_HANDLER,
65420 ZEND_NULL_HANDLER,
65421 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65422 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65423 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65424 ZEND_NULL_HANDLER,
65425 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65426 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65427 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65428 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65429 ZEND_NULL_HANDLER,
65430 ZEND_ADD_DOUBLE_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_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65437 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65438 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65439 ZEND_NULL_HANDLER,
65440 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65441 ZEND_NULL_HANDLER,
65442 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
65443 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
65444 ZEND_NULL_HANDLER,
65445 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
65446 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65447 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65448 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65449 ZEND_NULL_HANDLER,
65450 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65451 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65452 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65453 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65454 ZEND_NULL_HANDLER,
65455 ZEND_SUB_LONG_NO_OVERFLOW_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_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65462 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65463 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65464 ZEND_NULL_HANDLER,
65465 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65466 ZEND_NULL_HANDLER,
65467 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65468 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65469 ZEND_NULL_HANDLER,
65470 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65471 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65472 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65473 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65474 ZEND_NULL_HANDLER,
65475 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65476 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65477 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65478 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65479 ZEND_NULL_HANDLER,
65480 ZEND_SUB_LONG_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_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65487 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65488 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65489 ZEND_NULL_HANDLER,
65490 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65491 ZEND_NULL_HANDLER,
65492 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65493 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65494 ZEND_NULL_HANDLER,
65495 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65496 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65497 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65498 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65499 ZEND_NULL_HANDLER,
65500 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65501 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65502 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65503 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65504 ZEND_NULL_HANDLER,
65505 ZEND_SUB_DOUBLE_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_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65512 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65513 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65514 ZEND_NULL_HANDLER,
65515 ZEND_SUB_DOUBLE_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_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65522 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65523 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65524 ZEND_NULL_HANDLER,
65525 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65526 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65527 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65528 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65529 ZEND_NULL_HANDLER,
65530 ZEND_MUL_LONG_NO_OVERFLOW_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_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65537 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65538 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65539 ZEND_NULL_HANDLER,
65540 ZEND_MUL_LONG_NO_OVERFLOW_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_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65547 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65548 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65549 ZEND_NULL_HANDLER,
65550 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65551 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65552 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65553 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65554 ZEND_NULL_HANDLER,
65555 ZEND_MUL_LONG_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_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65562 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65563 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65564 ZEND_NULL_HANDLER,
65565 ZEND_MUL_LONG_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_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65572 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65573 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65574 ZEND_NULL_HANDLER,
65575 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65576 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65577 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65578 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65579 ZEND_NULL_HANDLER,
65580 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65581 ZEND_NULL_HANDLER,
65582 ZEND_NULL_HANDLER,
65583 ZEND_NULL_HANDLER,
65584 ZEND_NULL_HANDLER,
65585 ZEND_NULL_HANDLER,
65586 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65587 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65588 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65589 ZEND_NULL_HANDLER,
65590 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65591 ZEND_NULL_HANDLER,
65592 ZEND_NULL_HANDLER,
65593 ZEND_NULL_HANDLER,
65594 ZEND_NULL_HANDLER,
65595 ZEND_NULL_HANDLER,
65596 ZEND_NULL_HANDLER,
65597 ZEND_NULL_HANDLER,
65598 ZEND_NULL_HANDLER,
65599 ZEND_NULL_HANDLER,
65600 ZEND_NULL_HANDLER,
65601 ZEND_NULL_HANDLER,
65602 ZEND_NULL_HANDLER,
65603 ZEND_NULL_HANDLER,
65604 ZEND_NULL_HANDLER,
65605 ZEND_NULL_HANDLER,
65606 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65607 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65608 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65609 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65610 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65611 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65612 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65613 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65614 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65615 ZEND_NULL_HANDLER,
65616 ZEND_NULL_HANDLER,
65617 ZEND_NULL_HANDLER,
65618 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65619 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65620 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65621 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65622 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65623 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65624 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65625 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65626 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65627 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65628 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65629 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65630 ZEND_NULL_HANDLER,
65631 ZEND_NULL_HANDLER,
65632 ZEND_NULL_HANDLER,
65633 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65634 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65635 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65636 ZEND_NULL_HANDLER,
65637 ZEND_NULL_HANDLER,
65638 ZEND_NULL_HANDLER,
65639 ZEND_NULL_HANDLER,
65640 ZEND_NULL_HANDLER,
65641 ZEND_NULL_HANDLER,
65642 ZEND_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_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65652 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65653 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65654 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65655 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65656 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65657 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65658 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65659 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65660 ZEND_NULL_HANDLER,
65661 ZEND_NULL_HANDLER,
65662 ZEND_NULL_HANDLER,
65663 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65664 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65665 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65666 ZEND_NULL_HANDLER,
65667 ZEND_NULL_HANDLER,
65668 ZEND_NULL_HANDLER,
65669 ZEND_NULL_HANDLER,
65670 ZEND_NULL_HANDLER,
65671 ZEND_NULL_HANDLER,
65672 ZEND_NULL_HANDLER,
65673 ZEND_NULL_HANDLER,
65674 ZEND_NULL_HANDLER,
65675 ZEND_NULL_HANDLER,
65676 ZEND_NULL_HANDLER,
65677 ZEND_NULL_HANDLER,
65678 ZEND_NULL_HANDLER,
65679 ZEND_NULL_HANDLER,
65680 ZEND_NULL_HANDLER,
65681 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65682 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65683 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65684 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65685 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65686 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65687 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65688 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65689 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65690 ZEND_NULL_HANDLER,
65691 ZEND_NULL_HANDLER,
65692 ZEND_NULL_HANDLER,
65693 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65694 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65695 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65696 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65697 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65698 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65699 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65700 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65701 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65702 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65703 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65704 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65705 ZEND_NULL_HANDLER,
65706 ZEND_NULL_HANDLER,
65707 ZEND_NULL_HANDLER,
65708 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65709 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65710 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65711 ZEND_NULL_HANDLER,
65712 ZEND_NULL_HANDLER,
65713 ZEND_NULL_HANDLER,
65714 ZEND_NULL_HANDLER,
65715 ZEND_NULL_HANDLER,
65716 ZEND_NULL_HANDLER,
65717 ZEND_NULL_HANDLER,
65718 ZEND_NULL_HANDLER,
65719 ZEND_NULL_HANDLER,
65720 ZEND_NULL_HANDLER,
65721 ZEND_NULL_HANDLER,
65722 ZEND_NULL_HANDLER,
65723 ZEND_NULL_HANDLER,
65724 ZEND_NULL_HANDLER,
65725 ZEND_NULL_HANDLER,
65726 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65727 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65728 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65729 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65730 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65731 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65732 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65733 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65734 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65735 ZEND_NULL_HANDLER,
65736 ZEND_NULL_HANDLER,
65737 ZEND_NULL_HANDLER,
65738 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65739 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65740 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65741 ZEND_NULL_HANDLER,
65742 ZEND_NULL_HANDLER,
65743 ZEND_NULL_HANDLER,
65744 ZEND_NULL_HANDLER,
65745 ZEND_NULL_HANDLER,
65746 ZEND_NULL_HANDLER,
65747 ZEND_NULL_HANDLER,
65748 ZEND_NULL_HANDLER,
65749 ZEND_NULL_HANDLER,
65750 ZEND_NULL_HANDLER,
65751 ZEND_NULL_HANDLER,
65752 ZEND_NULL_HANDLER,
65753 ZEND_NULL_HANDLER,
65754 ZEND_NULL_HANDLER,
65755 ZEND_NULL_HANDLER,
65756 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65757 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65758 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65759 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65760 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65761 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65762 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65763 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65764 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65765 ZEND_NULL_HANDLER,
65766 ZEND_NULL_HANDLER,
65767 ZEND_NULL_HANDLER,
65768 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65769 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65770 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65771 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65772 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65773 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65774 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65775 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65776 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65777 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65778 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65779 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65780 ZEND_NULL_HANDLER,
65781 ZEND_NULL_HANDLER,
65782 ZEND_NULL_HANDLER,
65783 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65784 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65785 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65786 ZEND_NULL_HANDLER,
65787 ZEND_NULL_HANDLER,
65788 ZEND_NULL_HANDLER,
65789 ZEND_NULL_HANDLER,
65790 ZEND_NULL_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_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65802 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65803 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65804 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65805 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65806 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65807 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65808 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65809 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65810 ZEND_NULL_HANDLER,
65811 ZEND_NULL_HANDLER,
65812 ZEND_NULL_HANDLER,
65813 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65814 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65815 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65816 ZEND_NULL_HANDLER,
65817 ZEND_NULL_HANDLER,
65818 ZEND_NULL_HANDLER,
65819 ZEND_NULL_HANDLER,
65820 ZEND_NULL_HANDLER,
65821 ZEND_NULL_HANDLER,
65822 ZEND_NULL_HANDLER,
65823 ZEND_NULL_HANDLER,
65824 ZEND_NULL_HANDLER,
65825 ZEND_NULL_HANDLER,
65826 ZEND_NULL_HANDLER,
65827 ZEND_NULL_HANDLER,
65828 ZEND_NULL_HANDLER,
65829 ZEND_NULL_HANDLER,
65830 ZEND_NULL_HANDLER,
65831 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65832 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65833 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65834 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65835 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65836 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65837 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65838 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65839 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65840 ZEND_NULL_HANDLER,
65841 ZEND_NULL_HANDLER,
65842 ZEND_NULL_HANDLER,
65843 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65844 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65845 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65846 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65847 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65848 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65849 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65850 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65851 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65852 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65853 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65854 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65855 ZEND_NULL_HANDLER,
65856 ZEND_NULL_HANDLER,
65857 ZEND_NULL_HANDLER,
65858 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65859 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65860 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65861 ZEND_NULL_HANDLER,
65862 ZEND_NULL_HANDLER,
65863 ZEND_NULL_HANDLER,
65864 ZEND_NULL_HANDLER,
65865 ZEND_NULL_HANDLER,
65866 ZEND_NULL_HANDLER,
65867 ZEND_NULL_HANDLER,
65868 ZEND_NULL_HANDLER,
65869 ZEND_NULL_HANDLER,
65870 ZEND_NULL_HANDLER,
65871 ZEND_NULL_HANDLER,
65872 ZEND_NULL_HANDLER,
65873 ZEND_NULL_HANDLER,
65874 ZEND_NULL_HANDLER,
65875 ZEND_NULL_HANDLER,
65876 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65877 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65878 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65879 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65880 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65881 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65882 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65883 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65884 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65885 ZEND_NULL_HANDLER,
65886 ZEND_NULL_HANDLER,
65887 ZEND_NULL_HANDLER,
65888 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65889 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65890 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65891 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
65892 ZEND_NULL_HANDLER,
65893 ZEND_NULL_HANDLER,
65894 ZEND_NULL_HANDLER,
65895 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
65896 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
65897 ZEND_NULL_HANDLER,
65898 ZEND_NULL_HANDLER,
65899 ZEND_NULL_HANDLER,
65900 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
65901 ZEND_NULL_HANDLER,
65902 ZEND_NULL_HANDLER,
65903 ZEND_NULL_HANDLER,
65904 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65905 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65906 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65907 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65908 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65909 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65910 ZEND_NULL_HANDLER,
65911 ZEND_NULL_HANDLER,
65912 ZEND_NULL_HANDLER,
65913 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65914 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65915 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65916 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65917 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65918 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65919 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65920 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65921 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65922 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65923 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65924 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65925 ZEND_NULL_HANDLER,
65926 ZEND_NULL_HANDLER,
65927 ZEND_NULL_HANDLER,
65928 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65929 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65930 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65931 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65932 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65933 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65934 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65935 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65936 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65937 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65938 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65939 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65940 ZEND_NULL_HANDLER,
65941 ZEND_NULL_HANDLER,
65942 ZEND_NULL_HANDLER,
65943 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65944 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65945 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65946 ZEND_NULL_HANDLER,
65947 ZEND_NULL_HANDLER,
65948 ZEND_NULL_HANDLER,
65949 ZEND_NULL_HANDLER,
65950 ZEND_NULL_HANDLER,
65951 ZEND_NULL_HANDLER,
65952 ZEND_NULL_HANDLER,
65953 ZEND_NULL_HANDLER,
65954 ZEND_NULL_HANDLER,
65955 ZEND_NULL_HANDLER,
65956 ZEND_NULL_HANDLER,
65957 ZEND_NULL_HANDLER,
65958 ZEND_NULL_HANDLER,
65959 ZEND_NULL_HANDLER,
65960 ZEND_NULL_HANDLER,
65961 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65962 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65963 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65964 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65965 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65966 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65967 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65968 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65969 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65970 ZEND_NULL_HANDLER,
65971 ZEND_NULL_HANDLER,
65972 ZEND_NULL_HANDLER,
65973 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65974 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65975 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65976 ZEND_NULL_HANDLER,
65977 ZEND_NULL_HANDLER,
65978 ZEND_NULL_HANDLER,
65979 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65980 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65981 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65982 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65983 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65984 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65985 ZEND_NULL_HANDLER,
65986 ZEND_NULL_HANDLER,
65987 ZEND_NULL_HANDLER,
65988 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65989 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65990 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65991 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65992 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65993 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65994 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65995 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65996 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65997 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65998 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65999 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66000 ZEND_NULL_HANDLER,
66001 ZEND_NULL_HANDLER,
66002 ZEND_NULL_HANDLER,
66003 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66004 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66005 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66006 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66007 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66008 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66009 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66010 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66011 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66012 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66013 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66014 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66015 ZEND_NULL_HANDLER,
66016 ZEND_NULL_HANDLER,
66017 ZEND_NULL_HANDLER,
66018 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66019 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66020 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66021 ZEND_NULL_HANDLER,
66022 ZEND_NULL_HANDLER,
66023 ZEND_NULL_HANDLER,
66024 ZEND_NULL_HANDLER,
66025 ZEND_NULL_HANDLER,
66026 ZEND_NULL_HANDLER,
66027 ZEND_NULL_HANDLER,
66028 ZEND_NULL_HANDLER,
66029 ZEND_NULL_HANDLER,
66030 ZEND_NULL_HANDLER,
66031 ZEND_NULL_HANDLER,
66032 ZEND_NULL_HANDLER,
66033 ZEND_NULL_HANDLER,
66034 ZEND_NULL_HANDLER,
66035 ZEND_NULL_HANDLER,
66036 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66037 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66038 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66039 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66040 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66041 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66042 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66043 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66044 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66045 ZEND_NULL_HANDLER,
66046 ZEND_NULL_HANDLER,
66047 ZEND_NULL_HANDLER,
66048 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66049 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66050 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66051 ZEND_NULL_HANDLER,
66052 ZEND_NULL_HANDLER,
66053 ZEND_NULL_HANDLER,
66054 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66055 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66056 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66057 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66058 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66059 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66060 ZEND_NULL_HANDLER,
66061 ZEND_NULL_HANDLER,
66062 ZEND_NULL_HANDLER,
66063 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66064 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66065 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66066 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66067 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66068 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66069 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66070 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66071 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66072 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66073 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66074 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66075 ZEND_NULL_HANDLER,
66076 ZEND_NULL_HANDLER,
66077 ZEND_NULL_HANDLER,
66078 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66079 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66080 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66081 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66082 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66083 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66084 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66085 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66086 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66087 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66088 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66089 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66090 ZEND_NULL_HANDLER,
66091 ZEND_NULL_HANDLER,
66092 ZEND_NULL_HANDLER,
66093 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66094 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66095 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66096 ZEND_NULL_HANDLER,
66097 ZEND_NULL_HANDLER,
66098 ZEND_NULL_HANDLER,
66099 ZEND_NULL_HANDLER,
66100 ZEND_NULL_HANDLER,
66101 ZEND_NULL_HANDLER,
66102 ZEND_NULL_HANDLER,
66103 ZEND_NULL_HANDLER,
66104 ZEND_NULL_HANDLER,
66105 ZEND_NULL_HANDLER,
66106 ZEND_NULL_HANDLER,
66107 ZEND_NULL_HANDLER,
66108 ZEND_NULL_HANDLER,
66109 ZEND_NULL_HANDLER,
66110 ZEND_NULL_HANDLER,
66111 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66112 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66113 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66114 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66115 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66116 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66117 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66118 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66119 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66120 ZEND_NULL_HANDLER,
66121 ZEND_NULL_HANDLER,
66122 ZEND_NULL_HANDLER,
66123 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66124 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66125 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66126 ZEND_NULL_HANDLER,
66127 ZEND_NULL_HANDLER,
66128 ZEND_NULL_HANDLER,
66129 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66130 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66131 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66132 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66133 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66134 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66135 ZEND_NULL_HANDLER,
66136 ZEND_NULL_HANDLER,
66137 ZEND_NULL_HANDLER,
66138 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66139 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66140 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66141 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66142 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66143 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66144 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66145 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66146 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66147 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66148 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66149 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66150 ZEND_NULL_HANDLER,
66151 ZEND_NULL_HANDLER,
66152 ZEND_NULL_HANDLER,
66153 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66154 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66155 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66156 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66157 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66158 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66159 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66160 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66161 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66162 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66163 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66164 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66165 ZEND_NULL_HANDLER,
66166 ZEND_NULL_HANDLER,
66167 ZEND_NULL_HANDLER,
66168 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66169 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66170 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66171 ZEND_NULL_HANDLER,
66172 ZEND_NULL_HANDLER,
66173 ZEND_NULL_HANDLER,
66174 ZEND_NULL_HANDLER,
66175 ZEND_NULL_HANDLER,
66176 ZEND_NULL_HANDLER,
66177 ZEND_NULL_HANDLER,
66178 ZEND_NULL_HANDLER,
66179 ZEND_NULL_HANDLER,
66180 ZEND_NULL_HANDLER,
66181 ZEND_NULL_HANDLER,
66182 ZEND_NULL_HANDLER,
66183 ZEND_NULL_HANDLER,
66184 ZEND_NULL_HANDLER,
66185 ZEND_NULL_HANDLER,
66186 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66187 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66188 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66189 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66190 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66191 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66192 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66193 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66194 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66195 ZEND_NULL_HANDLER,
66196 ZEND_NULL_HANDLER,
66197 ZEND_NULL_HANDLER,
66198 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66199 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66200 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66201 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
66202 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
66203 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
66204 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
66205 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
66206 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
66207 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
66208 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
66209 ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
66210 ZEND_POST_INC_LONG_SPEC_CV_HANDLER,
66211 ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
66212 ZEND_POST_DEC_LONG_SPEC_CV_HANDLER,
66213 ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER,
66214 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
66215 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
66216 ZEND_NULL_HANDLER,
66217 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
66218 ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER,
66219 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
66220 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
66221 ZEND_NULL_HANDLER,
66222 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
66223 ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER,
66224 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
66225 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
66226 ZEND_NULL_HANDLER,
66227 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
66228 ZEND_NULL_HANDLER,
66229 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
66230 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
66231 ZEND_NULL_HANDLER,
66232 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
66233 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
66234 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66235 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66236 ZEND_NULL_HANDLER,
66237 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66238 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
66239 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66240 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66241 ZEND_NULL_HANDLER,
66242 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66243 ZEND_NULL_HANDLER,
66244 ZEND_NULL_HANDLER,
66245 ZEND_NULL_HANDLER,
66246 ZEND_NULL_HANDLER,
66247 ZEND_NULL_HANDLER,
66248 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER,
66249 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
66250 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
66251 ZEND_NULL_HANDLER,
66252 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
66253 ZEND_NULL_HANDLER,
66254 ZEND_NULL_HANDLER,
66255 ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER,
66256 ZEND_NULL_HANDLER,
66257 ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER,
66258 ZEND_NULL_HANDLER,
66259 ZEND_NULL_HANDLER,
66260 ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER,
66261 ZEND_NULL_HANDLER,
66262 ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER,
66263 ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER,
66264 ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER,
66265 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
66266 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER,
66267 ZEND_NULL_HANDLER
66268 };
66269 static const uint32_t specs[] = {
66270 0,
66271 1 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66272 26 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66273 51 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66274 76 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66275 101 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66276 126 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66277 151 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66278 176 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66279 201 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66280 226 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66281 251 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66282 276 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66283 301 | SPEC_RULE_OP1,
66284 306 | SPEC_RULE_OP1,
66285 311 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66286 336 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66287 361 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66288 386 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
66289 461 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
66290 536 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
66291 611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
66292 686 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL,
66293 736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
66294 861 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
66295 986 | SPEC_RULE_OP_DATA,
66296 991 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66297 1016 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66298 1041 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66299 1066,
66300 1067 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66301 1092 | SPEC_RULE_OP1,
66302 1097 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
66303 1222,
66304 1223 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
66305 1233 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
66306 1243 | SPEC_RULE_OP1,
66307 1248 | SPEC_RULE_OP1,
66308 1253,
66309 1253,
66310 1254,
66311 1254,
66312 1255,
66313 1256 | SPEC_RULE_OP1,
66314 1261 | SPEC_RULE_OP1,
66315 3482,
66316 1266 | SPEC_RULE_OP1,
66317 1271 | SPEC_RULE_OP1,
66318 1276 | SPEC_RULE_OP2,
66319 1281,
66320 1282 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
66321 1292 | SPEC_RULE_OP1,
66322 1297 | SPEC_RULE_OP1,
66323 1302 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66324 1327 | SPEC_RULE_OP2,
66325 1332 | SPEC_RULE_OP2,
66326 1337 | SPEC_RULE_OP2,
66327 1342,
66328 1343,
66329 1344,
66330 1345 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
66331 1349,
66332 1350 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
66333 1360,
66334 1361,
66335 1362 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66336 1387 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
66337 1437 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66338 1462 | SPEC_RULE_OP1,
66339 1467,
66340 1468,
66341 1469 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66342 1494 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66343 1519 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
66344 1529 | SPEC_RULE_OP1,
66345 1534 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66346 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66347 1584 | SPEC_RULE_OP1,
66348 1589,
66349 1590,
66350 1591 | SPEC_RULE_OP1,
66351 1596 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66352 1621 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66353 1646 | SPEC_RULE_OP1,
66354 1651 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66355 1676 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66356 1701 | SPEC_RULE_OP1,
66357 1706 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66358 1731 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66359 1756 | SPEC_RULE_OP1,
66360 1761 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66361 1786 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66362 1811 | SPEC_RULE_OP1,
66363 1816 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66364 1841 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66365 1866 | SPEC_RULE_OP1,
66366 1871 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66367 1896 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66368 1921 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66369 1946,
66370 1947 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
66371 1957,
66372 1958,
66373 1959,
66374 1960,
66375 1961,
66376 1962 | SPEC_RULE_OP2,
66377 1967,
66378 1968 | SPEC_RULE_OP1,
66379 1973 | SPEC_RULE_OP2,
66380 1978 | SPEC_RULE_OP1,
66381 1983 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
66382 1993 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66383 2018 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66384 2043 | SPEC_RULE_OP1,
66385 2048 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66386 2073 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
66387 2123 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66388 2148 | SPEC_RULE_OP2,
66389 2153,
66390 2154 | SPEC_RULE_OP1,
66391 2159 | SPEC_RULE_OP1,
66392 2164,
66393 2165 | SPEC_RULE_OP1,
66394 2170 | SPEC_RULE_OP1,
66395 2175 | SPEC_RULE_OP1,
66396 2180,
66397 2181,
66398 2182 | SPEC_RULE_OP2,
66399 2187 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
66400 2191 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
66401 2195 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
66402 2199 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66403 2199 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66404 2224 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66405 2224 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66406 2249 | SPEC_RULE_OP1,
66407 2254,
66408 2255 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66409 2280,
66410 2281 | SPEC_RULE_OP1,
66411 2286,
66412 2287,
66413 2288,
66414 2289,
66415 2290,
66416 2291,
66417 2292,
66418 2293 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66419 2318,
66420 2319,
66421 2320,
66422 2321 | SPEC_RULE_OP1,
66423 2326,
66424 2327 | SPEC_RULE_ISSET,
66425 2329 | SPEC_RULE_OP2,
66426 2334,
66427 2335 | SPEC_RULE_OP1,
66428 2340 | SPEC_RULE_OBSERVER,
66429 2342,
66430 2343 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66431 2368 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
66432 2378,
66433 2379,
66434 2380,
66435 2381,
66436 2382 | SPEC_RULE_OP1,
66437 2387,
66438 2388,
66439 2389 | SPEC_RULE_OP1,
66440 2394 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66441 2419,
66442 2420 | SPEC_RULE_OP1,
66443 2425,
66444 2426,
66445 2427,
66446 2428,
66447 2429,
66448 2430,
66449 2431,
66450 2432,
66451 2433 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66452 2458,
66453 2459,
66454 2460,
66455 2461 | SPEC_RULE_OP2,
66456 2466,
66457 2467 | SPEC_RULE_OP1,
66458 2472 | SPEC_RULE_OP1,
66459 2477 | SPEC_RULE_OP1,
66460 2482 | SPEC_RULE_OP1,
66461 2487 | SPEC_RULE_OP1,
66462 2492,
66463 2493 | SPEC_RULE_OP1,
66464 2498 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66465 2523 | SPEC_RULE_OP1,
66466 2528 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66467 2553 | SPEC_RULE_OP1,
66468 2558 | SPEC_RULE_OP1,
66469 2563,
66470 2564,
66471 2565,
66472 2566,
66473 2567,
66474 2568,
66475 2569,
66476 2570,
66477 2571,
66478 2572,
66479 3482,
66480 3482,
66481 3482,
66482 3482,
66483 3482,
66484 3482,
66485 3482,
66486 3482,
66487 3482,
66488 3482,
66489 3482,
66490 3482,
66491 3482,
66492 3482,
66493 3482,
66494 3482,
66495 3482,
66496 3482,
66497 3482,
66498 3482,
66499 3482,
66500 3482,
66501 3482,
66502 3482,
66503 3482,
66504 3482,
66505 3482,
66506 3482,
66507 3482,
66508 3482,
66509 3482,
66510 3482,
66511 3482,
66512 3482,
66513 3482,
66514 3482,
66515 3482,
66516 3482,
66517 3482,
66518 3482,
66519 3482,
66520 3482,
66521 3482,
66522 3482,
66523 3482,
66524 3482,
66525 3482,
66526 };
66527 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
66528 zend_opcode_handler_funcs = labels;
66529 zend_spec_handlers = specs;
66530 execute_ex(NULL);
66531 #else
66532 zend_opcode_handlers = labels;
66533 zend_handlers_count = sizeof(labels) / sizeof(void*);
66534 zend_spec_handlers = specs;
66535 #endif
66536 VM_TRACE_START();
66537 }
66538
66539 static HashTable *zend_handlers_table = NULL;
66540
66541 void zend_vm_dtor(void)
66542 {
66543 VM_TRACE_END();
66544 if (zend_handlers_table) {
66545 zend_hash_destroy(zend_handlers_table);
66546 free(zend_handlers_table);
66547 zend_handlers_table = NULL;
66548 }
66549 }
66550
66551 static void init_opcode_serialiser(void)
66552 {
66553 int i;
66554 zval tmp;
66555
66556 zend_handlers_table = malloc(sizeof(HashTable));
66557 zend_hash_init(zend_handlers_table, zend_handlers_count, NULL, NULL, 1);
66558 zend_hash_real_init(zend_handlers_table, 0);
66559 Z_TYPE_INFO(tmp) = IS_LONG;
66560 for (i = 0; i < zend_handlers_count; i++) {
66561 Z_LVAL(tmp) = i;
66562 zend_hash_index_add(zend_handlers_table, (zend_long)(uintptr_t)zend_opcode_handlers[i], &tmp);
66563 }
66564 }
66565
66566 ZEND_API void ZEND_FASTCALL zend_serialize_opcode_handler(zend_op *op)
66567 {
66568 zval *zv;
66569
66570 if (!zend_handlers_table) {
66571 init_opcode_serialiser();
66572 }
66573 zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
66574 ZEND_ASSERT(zv != NULL);
66575 op->handler = (const void *)(uintptr_t)Z_LVAL_P(zv);
66576 }
66577
66578 ZEND_API void ZEND_FASTCALL zend_deserialize_opcode_handler(zend_op *op)
66579 {
66580 op->handler = zend_opcode_handlers[(uintptr_t)op->handler];
66581 }
66582
66583 ZEND_API const void* ZEND_FASTCALL zend_get_opcode_handler_func(const zend_op *op)
66584 {
66585 #if ZEND_VM_KIND == ZEND_VM_KIND_CALL
66586 return op->handler;
66587 #elif ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
66588 zval *zv;
66589
66590 if (!zend_handlers_table) {
66591 init_opcode_serialiser();
66592 }
66593 zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
66594 ZEND_ASSERT(zv != NULL);
66595 return zend_opcode_handler_funcs[Z_LVAL_P(zv)];
66596 #else
66597 return NULL;
66598 #endif
66599 }
66600
66601 ZEND_API const zend_op *zend_get_halt_op(void)
66602 {
66603 #if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
66604 return &hybrid_halt_op;
66605 #else
66606 return NULL;
66607 #endif
66608 }
66609
66610 ZEND_API int zend_vm_kind(void)
66611 {
66612 return ZEND_VM_KIND;
66613 }
66614
66615 static uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec, const zend_op* op)
66616 {
66617 static const int zend_vm_decode[] = {
66618 _UNUSED_CODE, /* 0 = IS_UNUSED */
66619 _CONST_CODE, /* 1 = IS_CONST */
66620 _TMP_CODE, /* 2 = IS_TMP_VAR */
66621 _UNUSED_CODE, /* 3 */
66622 _VAR_CODE, /* 4 = IS_VAR */
66623 _UNUSED_CODE, /* 5 */
66624 _UNUSED_CODE, /* 6 */
66625 _UNUSED_CODE, /* 7 */
66626 _CV_CODE /* 8 = IS_CV */
66627 };
66628 uint32_t offset = 0;
66629 if (spec & SPEC_RULE_OP1) offset = offset * 5 + zend_vm_decode[op->op1_type];
66630 if (spec & SPEC_RULE_OP2) offset = offset * 5 + zend_vm_decode[op->op2_type];
66631 if (spec & SPEC_EXTRA_MASK) {
66632 if (spec & SPEC_RULE_RETVAL) {
66633 offset = offset * 2 + (op->result_type != IS_UNUSED);
66634 if ((spec & SPEC_RULE_OBSERVER) && ZEND_OBSERVER_ENABLED) {
66635 offset += 2;
66636 }
66637 } else if (spec & SPEC_RULE_QUICK_ARG) {
66638 offset = offset * 2 + (op->op2.num <= MAX_ARG_FLAG_NUM);
66639 } else if (spec & SPEC_RULE_OP_DATA) {
66640 offset = offset * 5 + zend_vm_decode[(op + 1)->op1_type];
66641 } else if (spec & SPEC_RULE_ISSET) {
66642 offset = offset * 2 + (op->extended_value & ZEND_ISEMPTY);
66643 } else if (spec & SPEC_RULE_SMART_BRANCH) {
66644 offset = offset * 3;
66645 if (op->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR)) {
66646 offset += 1;
66647 } else if (op->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)) {
66648 offset += 2;
66649 }
66650 } else if (spec & SPEC_RULE_OBSERVER) {
66651 offset = offset * 2;
66652 if (ZEND_OBSERVER_ENABLED) {
66653 offset += 1;
66654 }
66655 }
66656 }
66657 return (spec & SPEC_START_MASK) + offset;
66658 }
66659
66660 #if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC
66661 static const void *zend_vm_get_opcode_handler(uint8_t opcode, const zend_op* op)
66662 {
66663 return zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
66664 }
66665 #endif
66666
66667 #if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
66668 static const void *zend_vm_get_opcode_handler_func(uint8_t opcode, const zend_op* op)
66669 {
66670 uint32_t spec = zend_spec_handlers[opcode];
66671 return zend_opcode_handler_funcs[zend_vm_get_opcode_handler_idx(spec, op)];
66672 }
66673
66674 #endif
66675
66676 ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler(zend_op* op)
66677 {
66678 uint8_t opcode = zend_user_opcodes[op->opcode];
66679
66680 if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
66681 if (op->op1_type < op->op2_type) {
66682 zend_swap_operands(op);
66683 }
66684 }
66685 op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
66686 }
66687
66688 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)
66689 {
66690 uint8_t opcode = zend_user_opcodes[op->opcode];
66691 uint32_t spec = zend_spec_handlers[opcode];
66692 switch (opcode) {
66693 case ZEND_ADD:
66694 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66695 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66696 break;
66697 }
66698 spec = 2581 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66699 if (op->op1_type < op->op2_type) {
66700 zend_swap_operands(op);
66701 }
66702 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66703 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66704 break;
66705 }
66706 spec = 2606 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66707 if (op->op1_type < op->op2_type) {
66708 zend_swap_operands(op);
66709 }
66710 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66711 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66712 break;
66713 }
66714 spec = 2631 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66715 if (op->op1_type < op->op2_type) {
66716 zend_swap_operands(op);
66717 }
66718 }
66719 break;
66720 case ZEND_SUB:
66721 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66722 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66723 break;
66724 }
66725 spec = 2656 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
66726 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66727 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66728 break;
66729 }
66730 spec = 2681 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
66731 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66732 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66733 break;
66734 }
66735 spec = 2706 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
66736 }
66737 break;
66738 case ZEND_MUL:
66739 if (op->op1_type < op->op2_type) {
66740 zend_swap_operands(op);
66741 }
66742 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66743 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66744 break;
66745 }
66746 spec = 2731 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66747 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66748 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66749 break;
66750 }
66751 spec = 2756 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66752 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66753 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66754 break;
66755 }
66756 spec = 2781 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66757 }
66758 break;
66759 case ZEND_IS_IDENTICAL:
66760 if (op->op1_type < op->op2_type) {
66761 zend_swap_operands(op);
66762 }
66763 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66764 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66765 break;
66766 }
66767 spec = 2806 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66768 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66769 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66770 break;
66771 }
66772 spec = 2881 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66773 } 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))) {
66774 spec = 3106 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66775 }
66776 break;
66777 case ZEND_IS_NOT_IDENTICAL:
66778 if (op->op1_type < op->op2_type) {
66779 zend_swap_operands(op);
66780 }
66781 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66782 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66783 break;
66784 }
66785 spec = 2956 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66786 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66787 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66788 break;
66789 }
66790 spec = 3031 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66791 } 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))) {
66792 spec = 3111 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66793 }
66794 break;
66795 case ZEND_IS_EQUAL:
66796 if (op->op1_type < op->op2_type) {
66797 zend_swap_operands(op);
66798 }
66799 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66800 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66801 break;
66802 }
66803 spec = 2806 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66804 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66805 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66806 break;
66807 }
66808 spec = 2881 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66809 }
66810 break;
66811 case ZEND_IS_NOT_EQUAL:
66812 if (op->op1_type < op->op2_type) {
66813 zend_swap_operands(op);
66814 }
66815 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66816 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66817 break;
66818 }
66819 spec = 2956 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66820 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66821 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66822 break;
66823 }
66824 spec = 3031 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66825 }
66826 break;
66827 case ZEND_IS_SMALLER:
66828 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66829 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66830 break;
66831 }
66832 spec = 3116 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
66833 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66834 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66835 break;
66836 }
66837 spec = 3191 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
66838 }
66839 break;
66840 case ZEND_IS_SMALLER_OR_EQUAL:
66841 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66842 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66843 break;
66844 }
66845 spec = 3266 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
66846 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66847 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66848 break;
66849 }
66850 spec = 3341 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
66851 }
66852 break;
66853 case ZEND_QM_ASSIGN:
66854 if (op1_info == MAY_BE_LONG) {
66855 spec = 3428 | SPEC_RULE_OP1;
66856 } else if (op1_info == MAY_BE_DOUBLE) {
66857 spec = 3433 | SPEC_RULE_OP1;
66858 } 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))))) {
66859 spec = 3438 | SPEC_RULE_OP1;
66860 }
66861 break;
66862 case ZEND_PRE_INC:
66863 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
66864 spec = 3416 | SPEC_RULE_RETVAL;
66865 } else if (op1_info == MAY_BE_LONG) {
66866 spec = 3418 | SPEC_RULE_RETVAL;
66867 }
66868 break;
66869 case ZEND_PRE_DEC:
66870 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
66871 spec = 3420 | SPEC_RULE_RETVAL;
66872 } else if (op1_info == MAY_BE_LONG) {
66873 spec = 3422 | SPEC_RULE_RETVAL;
66874 }
66875 break;
66876 case ZEND_POST_INC:
66877 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
66878 spec = 3424;
66879 } else if (op1_info == MAY_BE_LONG) {
66880 spec = 3425;
66881 }
66882 break;
66883 case ZEND_POST_DEC:
66884 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
66885 spec = 3426;
66886 } else if (op1_info == MAY_BE_LONG) {
66887 spec = 3427;
66888 }
66889 break;
66890 case ZEND_JMP:
66891 if (OP_JMP_ADDR(op, op->op1) > op) {
66892 spec = 2580;
66893 }
66894 break;
66895 case ZEND_INIT_FCALL:
66896 if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) {
66897 spec = 2573;
66898 }
66899 break;
66900 case ZEND_RECV:
66901 if (op->op2.num == MAY_BE_ANY) {
66902 spec = 2574;
66903 }
66904 break;
66905 case ZEND_SEND_VAL:
66906 if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
66907 spec = 3478;
66908 }
66909 break;
66910 case ZEND_SEND_VAR_EX:
66911 if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
66912 spec = 3473 | SPEC_RULE_OP1;
66913 }
66914 break;
66915 case ZEND_FE_FETCH_R:
66916 if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
66917 spec = 3480 | SPEC_RULE_RETVAL;
66918 }
66919 break;
66920 case ZEND_FETCH_DIM_R:
66921 if (!(op2_info & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))) {
66922 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66923 break;
66924 }
66925 spec = 3443 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
66926 }
66927 break;
66928 case ZEND_SEND_VAL_EX:
66929 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))) {
66930 spec = 3479;
66931 }
66932 break;
66933 case ZEND_SEND_VAR:
66934 if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
66935 spec = 3468 | SPEC_RULE_OP1;
66936 }
66937 break;
66938 case ZEND_COUNT:
66939 if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) {
66940 spec = 2575 | SPEC_RULE_OP1;
66941 }
66942 break;
66943 case ZEND_BW_OR:
66944 case ZEND_BW_AND:
66945 case ZEND_BW_XOR:
66946 case ZEND_BOOL_XOR:
66947 if (op->op1_type < op->op2_type) {
66948 zend_swap_operands(op);
66949 }
66950 break;
66951 case ZEND_USER_OPCODE:
66952 if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
66953 if (op->op1_type < op->op2_type) {
66954 zend_swap_operands(op);
66955 }
66956 }
66957 break;
66958 default:
66959 break;
66960 }
66961 op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(spec, op)];
66962 }
66963
66964 ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data* ex)
66965 {
66966 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
66967 opcode_handler_t handler;
66968 #endif
66969 int ret;
66970 #ifdef ZEND_VM_IP_GLOBAL_REG
66971 const zend_op *orig_opline = opline;
66972 #endif
66973 #ifdef ZEND_VM_FP_GLOBAL_REG
66974 zend_execute_data *orig_execute_data = execute_data;
66975 execute_data = ex;
66976 #else
66977 zend_execute_data *execute_data = ex;
66978 #endif
66979
66980 LOAD_OPLINE();
66981 #if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
66982 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
66983 handler = (opcode_handler_t)zend_vm_get_opcode_handler_func(zend_user_opcodes[opline->opcode], opline);
66984 handler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
66985 if (EXPECTED(opline != &hybrid_halt_op)) {
66986 #else
66987 ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
66988 if (EXPECTED(opline)) {
66989 #endif
66990 ret = execute_data != ex ? (int)(execute_data->prev_execute_data != ex) + 1 : 0;
66991 SAVE_OPLINE();
66992 } else {
66993 ret = -1;
66994 }
66995 #else
66996 ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
66997 SAVE_OPLINE();
66998 #endif
66999 #ifdef ZEND_VM_FP_GLOBAL_REG
67000 execute_data = orig_execute_data;
67001 #endif
67002 #ifdef ZEND_VM_IP_GLOBAL_REG
67003 opline = orig_opline;
67004 #endif
67005 return ret;
67006 }
67007
67008
