1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1998-2016 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@zend.com> |
16 | Zeev Suraski <zeev@zend.com> |
17 | Dmitry Stogov <dmitry@zend.com> |
18 +----------------------------------------------------------------------+
19 */
20
21 #ifdef ZEND_WIN32
22 # pragma warning(once : 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 zend_uchar 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 static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op);
310
311
312 #undef OPLINE
313 #undef DCL_OPLINE
314 #undef USE_OPLINE
315 #undef LOAD_OPLINE
316 #undef SAVE_OPLINE
317 #define OPLINE EX(opline)
318 #define DCL_OPLINE
319 #define USE_OPLINE zend_op *opline = EX(opline);
320 #define LOAD_OPLINE()
321 #define SAVE_OPLINE()
322 #undef CHECK_EXCEPTION
323 #undef HANDLE_EXCEPTION
324 #undef HANDLE_EXCEPTION_LEAVE
325 #define CHECK_EXCEPTION() LOAD_OPLINE()
326 #define HANDLE_EXCEPTION() LOAD_OPLINE(); ZEND_VM_CONTINUE()
327 #define HANDLE_EXCEPTION_LEAVE() LOAD_OPLINE(); ZEND_VM_LEAVE()
328 #define LOAD_REGS()
329 #define ZEND_VM_CONTINUE() return 0
330 #define ZEND_VM_RETURN() return 1
331 #define ZEND_VM_ENTER() return 2
332 #define ZEND_VM_LEAVE() return 3
333 #define ZEND_VM_DISPATCH(opcode, opline) return zend_vm_get_opcode_handler(opcode, opline)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
334
335 #define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC
336
execute_ex(zend_execute_data * execute_data TSRMLS_DC)337 ZEND_API void execute_ex(zend_execute_data *execute_data TSRMLS_DC)
338 {
339 DCL_OPLINE
340 zend_bool original_in_execution;
341
342
343
344 original_in_execution = EG(in_execution);
345 EG(in_execution) = 1;
346
347 if (0) {
348 zend_vm_enter:
349 execute_data = i_create_execute_data_from_op_array(EG(active_op_array), 1 TSRMLS_CC);
350 }
351
352 LOAD_REGS();
353 LOAD_OPLINE();
354
355 while (1) {
356 int ret;
357 #ifdef ZEND_WIN32
358 if (EG(timed_out)) {
359 zend_timeout(0);
360 }
361 #endif
362
363 if ((ret = OPLINE->handler(execute_data TSRMLS_CC)) > 0) {
364 switch (ret) {
365 case 1:
366 EG(in_execution) = original_in_execution;
367 return;
368 case 2:
369 goto zend_vm_enter;
370 break;
371 case 3:
372 execute_data = EG(current_execute_data);
373 break;
374 default:
375 break;
376 }
377 }
378
379 }
380 zend_error_noreturn(E_ERROR, "Arrived at end of main loop which shouldn't happen");
381 }
382
zend_execute(zend_op_array * op_array TSRMLS_DC)383 ZEND_API void zend_execute(zend_op_array *op_array TSRMLS_DC)
384 {
385 if (EG(exception)) {
386 return;
387 }
388 zend_execute_ex(i_create_execute_data_from_op_array(op_array, 0 TSRMLS_CC) TSRMLS_CC);
389 }
390
zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)391 static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
392 {
393 zend_bool nested = EX(nested);
394 zend_op_array *op_array = EX(op_array);
395
396 EG(current_execute_data) = EX(prev_execute_data);
397 EG(opline_ptr) = NULL;
398 if (!EG(active_symbol_table)) {
399 i_free_compiled_variables(execute_data TSRMLS_CC);
400 }
401
402 zend_vm_stack_free((char*)execute_data - (ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T) TSRMLS_CC);
403
404 if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) {
405 zval_ptr_dtor((zval**)&op_array->prototype);
406 }
407
408 if (nested) {
409 execute_data = EG(current_execute_data);
410 }
411 if (nested) {
412 USE_OPLINE
413
414 LOAD_REGS();
415 LOAD_OPLINE();
416 if (UNEXPECTED(opline->opcode == ZEND_INCLUDE_OR_EVAL)) {
417
418 EX(function_state).function = (zend_function *) EX(op_array);
419 EX(function_state).arguments = NULL;
420
421 EG(opline_ptr) = &EX(opline);
422 EG(active_op_array) = EX(op_array);
423 EG(return_value_ptr_ptr) = EX(original_return_value);
424 destroy_op_array(op_array TSRMLS_CC);
425 efree(op_array);
426 if (UNEXPECTED(EG(exception) != NULL)) {
427 zend_throw_exception_internal(NULL TSRMLS_CC);
428 HANDLE_EXCEPTION_LEAVE();
429 }
430
431 ZEND_VM_INC_OPCODE();
432 ZEND_VM_LEAVE();
433 } else {
434 EG(opline_ptr) = &EX(opline);
435 EG(active_op_array) = EX(op_array);
436 EG(return_value_ptr_ptr) = EX(original_return_value);
437 if (EG(active_symbol_table)) {
438 zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
439 }
440 EG(active_symbol_table) = EX(symbol_table);
441
442 EX(function_state).function = (zend_function *) EX(op_array);
443 EX(function_state).arguments = NULL;
444
445 if (EG(This)) {
446 if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
447 if (EX(call)->is_ctor_result_used) {
448 Z_DELREF_P(EG(This));
449 }
450 if (Z_REFCOUNT_P(EG(This)) == 1) {
451 zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
452 }
453 }
454 zval_ptr_dtor(&EG(This));
455 }
456 EG(This) = EX(current_this);
457 EG(scope) = EX(current_scope);
458 EG(called_scope) = EX(current_called_scope);
459
460 EX(call)--;
461
462 zend_vm_stack_clear_multiple(0 TSRMLS_CC);
463
464 if (UNEXPECTED(EG(exception) != NULL)) {
465 zend_throw_exception_internal(NULL TSRMLS_CC);
466 if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) {
467 zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
468 }
469 HANDLE_EXCEPTION_LEAVE();
470 }
471
472 ZEND_VM_INC_OPCODE();
473 ZEND_VM_LEAVE();
474 }
475 }
476 ZEND_VM_RETURN();
477 }
478
zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)479 static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
480 {
481 USE_OPLINE
482 zend_bool should_change_scope = 0;
483 zend_function *fbc = EX(function_state).function;
484 zend_uint num_args;
485
486 SAVE_OPLINE();
487 EX(object) = EX(call)->object;
488 if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) {
489 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) {
490 zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name, fbc->common.function_name);
491 }
492 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
493 zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
494 fbc->common.scope ? fbc->common.scope->name : "",
495 fbc->common.scope ? "::" : "",
496 fbc->common.function_name);
497 if (UNEXPECTED(EG(exception) != NULL)) {
498 HANDLE_EXCEPTION();
499 }
500 }
501 }
502 if (fbc->common.scope &&
503 !(fbc->common.fn_flags & ZEND_ACC_STATIC) &&
504 !EX(object)) {
505
506 if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
507 /* FIXME: output identifiers properly */
508 zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name, fbc->common.function_name);
509 if (UNEXPECTED(EG(exception) != NULL)) {
510 HANDLE_EXCEPTION();
511 }
512 } else {
513 /* FIXME: output identifiers properly */
514 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
515 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name, fbc->common.function_name);
516 }
517 }
518
519 if (fbc->type == ZEND_USER_FUNCTION || fbc->common.scope) {
520 should_change_scope = 1;
521 EX(current_this) = EG(This);
522 EX(current_scope) = EG(scope);
523 EX(current_called_scope) = EG(called_scope);
524 EG(This) = EX(object);
525 EG(scope) = (fbc->type == ZEND_USER_FUNCTION || !EX(object)) ? fbc->common.scope : NULL;
526 EG(called_scope) = EX(call)->called_scope;
527 }
528
529 num_args = opline->extended_value + EX(call)->num_additional_args;
530 if (EX(call)->num_additional_args) {
531 EX(function_state).arguments = zend_vm_stack_push_args(num_args TSRMLS_CC);
532 } else {
533 EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
534 zend_vm_stack_push((void*)(zend_uintptr_t) num_args TSRMLS_CC);
535 }
536 LOAD_OPLINE();
537
538 if (fbc->type == ZEND_INTERNAL_FUNCTION) {
539 if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
540 zend_uint i;
541 void **p = EX(function_state).arguments - num_args;
542
543 for (i = 0; i < num_args; ++i, ++p) {
544 zend_verify_arg_type(fbc, i + 1, (zval *) *p, 0, NULL TSRMLS_CC);
545 }
546 }
547
548 if (EXPECTED(EG(exception) == NULL)) {
549 temp_variable *ret = &EX_T(opline->result.var);
550
551 MAKE_STD_ZVAL(ret->var.ptr);
552 ZVAL_NULL(ret->var.ptr);
553 ret->var.ptr_ptr = &ret->var.ptr;
554 ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
555
556 if (!zend_execute_internal) {
557 /* saves one function call if zend_execute_internal is not used */
558 fbc->internal_function.handler(num_args, ret->var.ptr, &ret->var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
559 } else {
560 zend_execute_internal(execute_data, NULL, RETURN_VALUE_USED(opline) TSRMLS_CC);
561 }
562
563 if (!RETURN_VALUE_USED(opline)) {
564 zval_ptr_dtor(&ret->var.ptr);
565 }
566 } else if (RETURN_VALUE_USED(opline)) {
567 EX_T(opline->result.var).var.ptr = NULL;
568 }
569 } else if (fbc->type == ZEND_USER_FUNCTION) {
570 temp_variable *ret = &EX_T(opline->result.var);
571 EX(original_return_value) = EG(return_value_ptr_ptr);
572 EG(active_symbol_table) = NULL;
573 EG(active_op_array) = &fbc->op_array;
574 EG(return_value_ptr_ptr) = NULL;
575 if (RETURN_VALUE_USED(opline)) {
576 ret->var.ptr = NULL;
577 EG(return_value_ptr_ptr) = &ret->var.ptr;
578 ret->var.ptr_ptr = &ret->var.ptr;
579 ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
580 }
581
582 if (UNEXPECTED((EG(active_op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
583 if (RETURN_VALUE_USED(opline)) {
584 ret->var.ptr = zend_generator_create_zval(EG(active_op_array) TSRMLS_CC);
585 ret->var.fcall_returned_reference = 0;
586 }
587 } else if (EXPECTED(zend_execute_ex == execute_ex)) {
588 if (EXPECTED(EG(exception) == NULL)) {
589 ZEND_VM_ENTER();
590 }
591 } else {
592 zend_execute(EG(active_op_array) TSRMLS_CC);
593 }
594
595 EG(opline_ptr) = &EX(opline);
596 EG(active_op_array) = EX(op_array);
597 EG(return_value_ptr_ptr) = EX(original_return_value);
598 if (EG(active_symbol_table)) {
599 zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
600 }
601 EG(active_symbol_table) = EX(symbol_table);
602 } else { /* ZEND_OVERLOADED_FUNCTION */
603 MAKE_STD_ZVAL(EX_T(opline->result.var).var.ptr);
604 ZVAL_NULL(EX_T(opline->result.var).var.ptr);
605
606 /* Not sure what should be done here if it's a static method */
607 if (EXPECTED(EX(object) != NULL)) {
608 Z_OBJ_HT_P(EX(object))->call_method(fbc->common.function_name, num_args, EX_T(opline->result.var).var.ptr, &EX_T(opline->result.var).var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
609 } else {
610 zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
611 }
612
613 if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
614 efree((char*)fbc->common.function_name);
615 }
616 efree(fbc);
617
618 if (!RETURN_VALUE_USED(opline)) {
619 zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
620 } else {
621 Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr);
622 Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1);
623 EX_T(opline->result.var).var.fcall_returned_reference = 0;
624 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
625 }
626 }
627
628 EX(function_state).function = (zend_function *) EX(op_array);
629 EX(function_state).arguments = NULL;
630
631 if (should_change_scope) {
632 if (EG(This)) {
633 if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
634 if (EX(call)->is_ctor_result_used) {
635 Z_DELREF_P(EG(This));
636 }
637 if (Z_REFCOUNT_P(EG(This)) == 1) {
638 zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
639 }
640 }
641 zval_ptr_dtor(&EG(This));
642 }
643 EG(This) = EX(current_this);
644 EG(scope) = EX(current_scope);
645 EG(called_scope) = EX(current_called_scope);
646 }
647
648 EX(call)--;
649
650 zend_vm_stack_clear_multiple(0 TSRMLS_CC);
651
652 if (UNEXPECTED(EG(exception) != NULL)) {
653 zend_throw_exception_internal(NULL TSRMLS_CC);
654 if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) {
655 zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
656 }
657 HANDLE_EXCEPTION();
658 }
659
660 ZEND_VM_NEXT_OPCODE();
661 }
662
ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)663 static int ZEND_FASTCALL ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
664 {
665 USE_OPLINE
666
667 #if DEBUG_ZEND>=2
668 printf("Jumping to %d\n", opline->op1.opline_num);
669 #endif
670 ZEND_VM_SET_OPCODE(opline->op1.jmp_addr);
671 ZEND_VM_CONTINUE();
672 }
673
ZEND_INIT_STRING_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)674 static int ZEND_FASTCALL ZEND_INIT_STRING_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
675 {
676 USE_OPLINE
677 zval *tmp = &EX_T(opline->result.var).tmp_var;
678
679 SAVE_OPLINE();
680 tmp->value.str.val = emalloc(1);
681 tmp->value.str.val[0] = 0;
682 tmp->value.str.len = 0;
683 Z_SET_REFCOUNT_P(tmp, 1);
684 tmp->type = IS_STRING;
685 Z_UNSET_ISREF_P(tmp);
686 /*CHECK_EXCEPTION();*/
687 ZEND_VM_NEXT_OPCODE();
688 }
689
ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)690 static int ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
691 {
692 EX(function_state).function = EX(call)->fbc;
693 return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
694 }
695
ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)696 static int ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
697 {
698 /* The generator object is stored in return_value_ptr_ptr */
699 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
700
701 /* Close the generator to free up resources */
702 zend_generator_close(generator, 1 TSRMLS_CC);
703
704 /* Pass execution back to handling code */
705 ZEND_VM_RETURN();
706 }
707
ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)708 static int ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
709 {
710 USE_OPLINE
711 zend_free_op free_op1;
712 zval *args;
713 int arg_num;
714 SAVE_OPLINE();
715
716 args = get_zval_ptr(opline->op1_type, &opline->op1, execute_data, &free_op1, BP_VAR_R);
717 arg_num = opline->op2.num + EX(call)->num_additional_args + 1;
718
719 switch (Z_TYPE_P(args)) {
720 case IS_ARRAY: {
721 HashTable *ht = Z_ARRVAL_P(args);
722 HashPosition pos;
723 zval **arg_ptr, *arg;
724
725 ZEND_VM_STACK_GROW_IF_NEEDED(zend_hash_num_elements(ht));
726
727 for (zend_hash_internal_pointer_reset_ex(ht, &pos);
728 zend_hash_get_current_data_ex(ht, (void **) &arg_ptr, &pos) == SUCCESS;
729 zend_hash_move_forward_ex(ht, &pos), ++arg_num
730 ) {
731 char *name;
732 zend_uint name_len;
733 zend_ulong index;
734
735 if (zend_hash_get_current_key_ex(ht, &name, &name_len, &index, 0, &pos) == HASH_KEY_IS_STRING) {
736 zend_error(E_RECOVERABLE_ERROR, "Cannot unpack array with string keys");
737 FREE_OP(free_op1);
738 CHECK_EXCEPTION();
739 ZEND_VM_NEXT_OPCODE();
740 }
741
742 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
743 SEPARATE_ZVAL_TO_MAKE_IS_REF(arg_ptr);
744 arg = *arg_ptr;
745 Z_ADDREF_P(arg);
746 } else if (Z_ISREF_PP(arg_ptr)) {
747 ALLOC_ZVAL(arg);
748 MAKE_COPY_ZVAL(arg_ptr, arg);
749 } else {
750 arg = *arg_ptr;
751 Z_ADDREF_P(arg);
752 }
753
754 zend_vm_stack_push(arg TSRMLS_CC);
755 EX(call)->num_additional_args++;
756 }
757 break;
758 }
759 case IS_OBJECT: {
760 zend_class_entry *ce = Z_OBJCE_P(args);
761 zend_object_iterator *iter;
762
763 if (!ce || !ce->get_iterator) {
764 zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
765 break;
766 }
767
768 iter = ce->get_iterator(ce, args, 0 TSRMLS_CC);
769 if (UNEXPECTED(!iter)) {
770 FREE_OP(free_op1);
771 if (!EG(exception)) {
772 zend_throw_exception_ex(
773 NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name
774 );
775 }
776 HANDLE_EXCEPTION();
777 }
778
779 if (iter->funcs->rewind) {
780 iter->funcs->rewind(iter TSRMLS_CC);
781 if (UNEXPECTED(EG(exception) != NULL)) {
782 goto unpack_iter_dtor;
783 }
784 }
785
786 for (; iter->funcs->valid(iter TSRMLS_CC) == SUCCESS; ++arg_num) {
787 zval **arg_ptr, *arg;
788
789 if (UNEXPECTED(EG(exception) != NULL)) {
790 goto unpack_iter_dtor;
791 }
792
793 iter->funcs->get_current_data(iter, &arg_ptr TSRMLS_CC);
794 if (UNEXPECTED(EG(exception) != NULL)) {
795 goto unpack_iter_dtor;
796 }
797
798 if (iter->funcs->get_current_key) {
799 zval key;
800 iter->funcs->get_current_key(iter, &key TSRMLS_CC);
801 if (UNEXPECTED(EG(exception) != NULL)) {
802 goto unpack_iter_dtor;
803 }
804
805 if (Z_TYPE(key) == IS_STRING) {
806 zend_error(E_RECOVERABLE_ERROR,
807 "Cannot unpack Traversable with string keys");
808 zval_dtor(&key);
809 goto unpack_iter_dtor;
810 }
811
812 zval_dtor(&key);
813 }
814
815 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
816 zend_error(
817 E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
818 " by unpacking a Traversable, passing by-value instead", arg_num,
819 EX(call)->fbc->common.scope ? EX(call)->fbc->common.scope->name : "",
820 EX(call)->fbc->common.scope ? "::" : "",
821 EX(call)->fbc->common.function_name
822 );
823 }
824
825 if (Z_ISREF_PP(arg_ptr)) {
826 ALLOC_ZVAL(arg);
827 MAKE_COPY_ZVAL(arg_ptr, arg);
828 } else {
829 arg = *arg_ptr;
830 Z_ADDREF_P(arg);
831 }
832
833 ZEND_VM_STACK_GROW_IF_NEEDED(1);
834 zend_vm_stack_push(arg TSRMLS_CC);
835 EX(call)->num_additional_args++;
836
837 iter->funcs->move_forward(iter TSRMLS_CC);
838 if (UNEXPECTED(EG(exception) != NULL)) {
839 goto unpack_iter_dtor;
840 }
841 }
842
843 unpack_iter_dtor:
844 iter->funcs->dtor(iter TSRMLS_CC);
845 break;
846 }
847 default:
848 zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
849 }
850
851 FREE_OP(free_op1);
852 CHECK_EXCEPTION();
853 ZEND_VM_NEXT_OPCODE();
854 }
855
ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)856 static int ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
857 {
858 USE_OPLINE
859 zend_uint arg_num = opline->op1.num;
860 zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
861
862 SAVE_OPLINE();
863 if (UNEXPECTED(param == NULL)) {
864 if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value, NULL TSRMLS_CC)) {
865 const char *space;
866 const char *class_name;
867 zend_execute_data *ptr;
868
869 if (EG(active_op_array)->scope) {
870 class_name = EG(active_op_array)->scope->name;
871 space = "::";
872 } else {
873 class_name = space = "";
874 }
875 ptr = EX(prev_execute_data);
876
877 if(ptr && ptr->op_array) {
878 zend_error(E_WARNING, "Missing argument %u for %s%s%s(), called in %s on line %d and defined", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno);
879 } else {
880 zend_error(E_WARNING, "Missing argument %u for %s%s%s()", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C));
881 }
882 }
883 } else {
884 zval **var_ptr;
885
886 zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value, NULL TSRMLS_CC);
887 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
888 Z_DELREF_PP(var_ptr);
889 *var_ptr = *param;
890 Z_ADDREF_PP(var_ptr);
891 }
892
893 CHECK_EXCEPTION();
894 ZEND_VM_NEXT_OPCODE();
895 }
896
ZEND_RECV_VARIADIC_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)897 static int ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
898 {
899 USE_OPLINE
900 zend_uint arg_num = opline->op1.num;
901 zend_uint arg_count = zend_vm_stack_get_args_count(TSRMLS_C);
902 zval **var_ptr, *params;
903
904 SAVE_OPLINE();
905
906 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
907 Z_DELREF_PP(var_ptr);
908 MAKE_STD_ZVAL(params);
909 *var_ptr = params;
910
911 if (arg_num <= arg_count) {
912 array_init_size(params, arg_count - arg_num + 1);
913 } else {
914 array_init(params);
915 }
916
917 for (; arg_num <= arg_count; ++arg_num) {
918 zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
919 zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value, NULL TSRMLS_CC);
920 zend_hash_next_index_insert(Z_ARRVAL_P(params), param, sizeof(zval *), NULL);
921 Z_ADDREF_PP(param);
922 }
923
924 CHECK_EXCEPTION();
925 ZEND_VM_NEXT_OPCODE();
926 }
927
ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)928 static int ZEND_FASTCALL ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
929 {
930 USE_OPLINE
931 zval *object_zval;
932 zend_function *constructor;
933
934 SAVE_OPLINE();
935 if (UNEXPECTED((EX_T(opline->op1.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) != 0)) {
936 if (EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
937 zend_error_noreturn(E_ERROR, "Cannot instantiate interface %s", EX_T(opline->op1.var).class_entry->name);
938 } else if ((EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
939 zend_error_noreturn(E_ERROR, "Cannot instantiate trait %s", EX_T(opline->op1.var).class_entry->name);
940 } else {
941 zend_error_noreturn(E_ERROR, "Cannot instantiate abstract class %s", EX_T(opline->op1.var).class_entry->name);
942 }
943 }
944 ALLOC_ZVAL(object_zval);
945 object_init_ex(object_zval, EX_T(opline->op1.var).class_entry);
946 INIT_PZVAL(object_zval);
947
948 constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
949
950 if (constructor == NULL) {
951 if (RETURN_VALUE_USED(opline)) {
952 AI_SET_PTR(&EX_T(opline->result.var), object_zval);
953 } else {
954 zval_ptr_dtor(&object_zval);
955 }
956 ZEND_VM_JMP(EX(op_array)->opcodes + opline->op2.opline_num);
957 } else {
958 call_slot *call = EX(call_slots) + opline->extended_value;
959
960 if (RETURN_VALUE_USED(opline)) {
961 PZVAL_LOCK(object_zval);
962 AI_SET_PTR(&EX_T(opline->result.var), object_zval);
963 }
964
965 /* We are not handling overloaded classes right now */
966 call->fbc = constructor;
967 call->object = object_zval;
968 call->called_scope = EX_T(opline->op1.var).class_entry;
969 call->num_additional_args = 0;
970 call->is_ctor_call = 1;
971 call->is_ctor_result_used = RETURN_VALUE_USED(opline);
972 EX(call) = call;
973
974 CHECK_EXCEPTION();
975 ZEND_VM_NEXT_OPCODE();
976 }
977 }
978
ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)979 static int ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
980 {
981 USE_OPLINE
982
983 SAVE_OPLINE();
984 Z_LVAL(EX_T(opline->result.var).tmp_var) = EG(error_reporting);
985 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_LONG; /* shouldn't be necessary */
986 if (EX(old_error_reporting) == NULL) {
987 EX(old_error_reporting) = &EX_T(opline->result.var).tmp_var;
988 }
989
990 if (EG(error_reporting)) {
991 do {
992 EG(error_reporting) = 0;
993 if (!EG(error_reporting_ini_entry)) {
994 if (UNEXPECTED(zend_hash_find(EG(ini_directives), "error_reporting", sizeof("error_reporting"), (void **) &EG(error_reporting_ini_entry)) == FAILURE)) {
995 break;
996 }
997 }
998 if (!EG(error_reporting_ini_entry)->modified) {
999 if (!EG(modified_ini_directives)) {
1000 ALLOC_HASHTABLE(EG(modified_ini_directives));
1001 zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
1002 }
1003 if (EXPECTED(zend_hash_add(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting"), &EG(error_reporting_ini_entry), sizeof(zend_ini_entry*), NULL) == SUCCESS)) {
1004 EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
1005 EG(error_reporting_ini_entry)->orig_value_length = EG(error_reporting_ini_entry)->value_length;
1006 EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
1007 EG(error_reporting_ini_entry)->modified = 1;
1008 }
1009 } else if (EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value) {
1010 efree(EG(error_reporting_ini_entry)->value);
1011 }
1012 EG(error_reporting_ini_entry)->value = estrndup("0", sizeof("0")-1);
1013 EG(error_reporting_ini_entry)->value_length = sizeof("0")-1;
1014 } while (0);
1015 }
1016 CHECK_EXCEPTION();
1017 ZEND_VM_NEXT_OPCODE();
1018 }
1019
ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1020 static int ZEND_FASTCALL ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1021 {
1022 SAVE_OPLINE();
1023 zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name);
1024 ZEND_VM_NEXT_OPCODE(); /* Never reached */
1025 }
1026
ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1027 static int ZEND_FASTCALL ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1028 {
1029 SAVE_OPLINE();
1030 if (!EG(no_extensions)) {
1031 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, EX(op_array) TSRMLS_CC);
1032 }
1033 CHECK_EXCEPTION();
1034 ZEND_VM_NEXT_OPCODE();
1035 }
1036
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1037 static int ZEND_FASTCALL ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1038 {
1039 SAVE_OPLINE();
1040 if (!EG(no_extensions)) {
1041 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, EX(op_array) TSRMLS_CC);
1042 }
1043 CHECK_EXCEPTION();
1044 ZEND_VM_NEXT_OPCODE();
1045 }
1046
ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1047 static int ZEND_FASTCALL ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1048 {
1049 SAVE_OPLINE();
1050 if (!EG(no_extensions)) {
1051 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, EX(op_array) TSRMLS_CC);
1052 }
1053 CHECK_EXCEPTION();
1054 ZEND_VM_NEXT_OPCODE();
1055 }
1056
ZEND_DECLARE_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1057 static int ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1058 {
1059 USE_OPLINE
1060
1061 SAVE_OPLINE();
1062 EX_T(opline->result.var).class_entry = do_bind_class(EX(op_array), opline, EG(class_table), 0 TSRMLS_CC);
1063 CHECK_EXCEPTION();
1064 ZEND_VM_NEXT_OPCODE();
1065 }
1066
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1067 static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1068 {
1069 USE_OPLINE
1070
1071 SAVE_OPLINE();
1072 EX_T(opline->result.var).class_entry = do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
1073 CHECK_EXCEPTION();
1074 ZEND_VM_NEXT_OPCODE();
1075 }
1076
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1077 static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1078 {
1079 USE_OPLINE
1080 zend_class_entry **pce, **pce_orig;
1081
1082 SAVE_OPLINE();
1083 if (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void**)&pce) == FAILURE ||
1084 (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void**)&pce_orig) == SUCCESS &&
1085 *pce != *pce_orig)) {
1086 do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
1087 }
1088 CHECK_EXCEPTION();
1089 ZEND_VM_NEXT_OPCODE();
1090 }
1091
ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1092 static int ZEND_FASTCALL ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1093 {
1094 USE_OPLINE
1095
1096 SAVE_OPLINE();
1097 do_bind_function(EX(op_array), opline, EG(function_table), 0);
1098 CHECK_EXCEPTION();
1099 ZEND_VM_NEXT_OPCODE();
1100 }
1101
ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1102 static int ZEND_FASTCALL ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1103 {
1104 USE_OPLINE
1105
1106 SAVE_OPLINE();
1107 if (++EG(ticks_count)>=opline->extended_value) {
1108 EG(ticks_count)=0;
1109 if (zend_ticks_function) {
1110 zend_ticks_function(opline->extended_value);
1111 }
1112 }
1113 CHECK_EXCEPTION();
1114 ZEND_VM_NEXT_OPCODE();
1115 }
1116
ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1117 static int ZEND_FASTCALL ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1118 {
1119 ZEND_VM_NEXT_OPCODE();
1120 }
1121
ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1122 static int ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1123 {
1124 ZEND_VM_NEXT_OPCODE();
1125 }
1126
ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1127 static int ZEND_FASTCALL ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1128 {
1129 USE_OPLINE
1130 zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
1131 zend_class_entry *trait;
1132
1133 SAVE_OPLINE();
1134 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1135 trait = CACHED_PTR(opline->op2.literal->cache_slot);
1136 } else {
1137 trait = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv),
1138 Z_STRLEN_P(opline->op2.zv),
1139 opline->op2.literal + 1,
1140 opline->extended_value TSRMLS_CC);
1141 if (UNEXPECTED(trait == NULL)) {
1142 CHECK_EXCEPTION();
1143 ZEND_VM_NEXT_OPCODE();
1144 }
1145 if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) {
1146 zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name, trait->name);
1147 }
1148 CACHE_PTR(opline->op2.literal->cache_slot, trait);
1149 }
1150
1151 zend_do_implement_trait(ce, trait TSRMLS_CC);
1152
1153 CHECK_EXCEPTION();
1154 ZEND_VM_NEXT_OPCODE();
1155 }
1156
ZEND_BIND_TRAITS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1157 static int ZEND_FASTCALL ZEND_BIND_TRAITS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1158 {
1159 USE_OPLINE
1160 zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
1161
1162 SAVE_OPLINE();
1163 zend_do_bind_traits(ce TSRMLS_CC);
1164 CHECK_EXCEPTION();
1165 ZEND_VM_NEXT_OPCODE();
1166 }
1167
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1168 static int ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1169 {
1170 zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes;
1171 int i;
1172 zend_uint catch_op_num = 0, finally_op_num = 0, finally_op_end = 0;
1173 void **stack_frame;
1174
1175 /* Figure out where the next stack frame (which maybe contains pushed
1176 * arguments that have to be dtor'ed) starts */
1177 stack_frame = zend_vm_stack_frame_base(execute_data);
1178
1179 /* If the exception was thrown during a function call there might be
1180 * arguments pushed to the stack that have to be dtor'ed. */
1181 while (zend_vm_stack_top(TSRMLS_C) != stack_frame) {
1182 zval *stack_zval_p = zend_vm_stack_pop(TSRMLS_C);
1183 zval_ptr_dtor(&stack_zval_p);
1184 }
1185
1186 for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
1187 if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
1188 /* further blocks will not be relevant... */
1189 break;
1190 }
1191 if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
1192 catch_op_num = EX(op_array)->try_catch_array[i].catch_op;
1193 }
1194 if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
1195 finally_op_num = EX(op_array)->try_catch_array[i].finally_op;
1196 }
1197 if (op_num >= EG(active_op_array)->try_catch_array[i].finally_op &&
1198 op_num < EG(active_op_array)->try_catch_array[i].finally_end) {
1199 finally_op_end = EG(active_op_array)->try_catch_array[i].finally_end;
1200 }
1201 }
1202
1203 if (EX(call) >= EX(call_slots)) {
1204 call_slot *call = EX(call);
1205 do {
1206 if (call->object) {
1207 if (call->is_ctor_call) {
1208 if (call->is_ctor_result_used) {
1209 Z_DELREF_P(call->object);
1210 }
1211 if (Z_REFCOUNT_P(call->object) == 1) {
1212 zend_object_store_ctor_failed(call->object TSRMLS_CC);
1213 }
1214 }
1215 zval_ptr_dtor(&call->object);
1216 }
1217 if (call->fbc->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) {
1218 efree((char *) call->fbc->common.function_name);
1219 efree(call->fbc);
1220 }
1221 call--;
1222 } while (call >= EX(call_slots));
1223 EX(call) = NULL;
1224 }
1225
1226 for (i=0; i<EX(op_array)->last_brk_cont; i++) {
1227 if (EX(op_array)->brk_cont_array[i].start < 0) {
1228 continue;
1229 } else if (EX(op_array)->brk_cont_array[i].start > op_num) {
1230 /* further blocks will not be relevant... */
1231 break;
1232 } else if (op_num < EX(op_array)->brk_cont_array[i].brk) {
1233 if (!catch_op_num ||
1234 catch_op_num >= EX(op_array)->brk_cont_array[i].brk) {
1235 zend_op *brk_opline = &EX(op_array)->opcodes[EX(op_array)->brk_cont_array[i].brk];
1236
1237 switch (brk_opline->opcode) {
1238 case ZEND_SWITCH_FREE:
1239 if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
1240 zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
1241 }
1242 break;
1243 case ZEND_FREE:
1244 if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
1245 zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
1246 }
1247 break;
1248 }
1249 }
1250 }
1251 }
1252
1253 /* restore previous error_reporting value */
1254 if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) {
1255 zval restored_error_reporting;
1256
1257 Z_TYPE(restored_error_reporting) = IS_LONG;
1258 Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting));
1259 convert_to_string(&restored_error_reporting);
1260 zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
1261 zendi_zval_dtor(restored_error_reporting);
1262 }
1263 EX(old_error_reporting) = NULL;
1264
1265 if (finally_op_num && (!catch_op_num || catch_op_num >= finally_op_num)) {
1266 if (EX(delayed_exception)) {
1267 zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
1268 }
1269 EX(delayed_exception) = EG(exception);
1270 EG(exception) = NULL;
1271 EX(fast_ret) = NULL;
1272 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
1273 ZEND_VM_CONTINUE();
1274 } else if (catch_op_num) {
1275 if (finally_op_end && catch_op_num > finally_op_end) {
1276 /* we are going out of current finally scope */
1277 if (EX(delayed_exception)) {
1278 zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
1279 EX(delayed_exception) = NULL;
1280 }
1281 }
1282 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
1283 ZEND_VM_CONTINUE();
1284 } else {
1285 if (EX(delayed_exception)) {
1286 zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
1287 EX(delayed_exception) = NULL;
1288 }
1289 if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
1290 return ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1291 } else {
1292 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1293 }
1294 }
1295 }
1296
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1297 static int ZEND_FASTCALL ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1298 {
1299 USE_OPLINE
1300
1301 SAVE_OPLINE();
1302 zend_verify_abstract_class(EX_T(opline->op1.var).class_entry TSRMLS_CC);
1303 CHECK_EXCEPTION();
1304 ZEND_VM_NEXT_OPCODE();
1305 }
1306
ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1307 static int ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1308 {
1309 USE_OPLINE
1310 int ret;
1311
1312 SAVE_OPLINE();
1313 ret = zend_user_opcode_handlers[opline->opcode](ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL);
1314 LOAD_OPLINE();
1315
1316 switch (ret) {
1317 case ZEND_USER_OPCODE_CONTINUE:
1318 ZEND_VM_CONTINUE();
1319 case ZEND_USER_OPCODE_RETURN:
1320 if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
1321 return ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1322 } else {
1323 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1324 }
1325 case ZEND_USER_OPCODE_ENTER:
1326 ZEND_VM_ENTER();
1327 case ZEND_USER_OPCODE_LEAVE:
1328 ZEND_VM_LEAVE();
1329 case ZEND_USER_OPCODE_DISPATCH:
1330 ZEND_VM_DISPATCH(opline->opcode, opline);
1331 default:
1332 ZEND_VM_DISPATCH((zend_uchar)(ret & 0xff), opline);
1333 }
1334 }
1335
ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1336 static int ZEND_FASTCALL ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1337 {
1338 if (EX(delayed_exception) != NULL) {
1339 /* discard the previously thrown exception */
1340 zval_ptr_dtor(&EX(delayed_exception));
1341 EX(delayed_exception) = NULL;
1342 }
1343
1344 ZEND_VM_NEXT_OPCODE();
1345 }
1346
ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1347 static int ZEND_FASTCALL ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1348 {
1349 USE_OPLINE
1350
1351 if ((opline->extended_value & ZEND_FAST_CALL_FROM_CATCH) &&
1352 UNEXPECTED(EG(prev_exception) != NULL)) {
1353 /* in case of unhandled exception jump to catch block instead of finally */
1354 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
1355 ZEND_VM_CONTINUE();
1356 }
1357 if (UNEXPECTED(EX(delayed_exception) != NULL)) {
1358 EX(fast_ret) = NULL;
1359 } else {
1360 EX(fast_ret) = opline;
1361 }
1362 ZEND_VM_SET_OPCODE(opline->op1.jmp_addr);
1363 ZEND_VM_CONTINUE();
1364 }
1365
ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1366 static int ZEND_FASTCALL ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1367 {
1368 if (EX(fast_ret)) {
1369 ZEND_VM_SET_OPCODE(EX(fast_ret) + 1);
1370 if ((EX(fast_ret)->extended_value & ZEND_FAST_CALL_FROM_FINALLY)) {
1371 EX(fast_ret) = &EX(op_array)->opcodes[EX(fast_ret)->op2.opline_num];
1372 }
1373 ZEND_VM_CONTINUE();
1374 } else {
1375 /* special case for unhandled exceptions */
1376 USE_OPLINE
1377
1378 if (opline->extended_value == ZEND_FAST_RET_TO_FINALLY) {
1379 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
1380 ZEND_VM_CONTINUE();
1381 } else {
1382 EG(exception) = EX(delayed_exception);
1383 EX(delayed_exception) = NULL;
1384 if (opline->extended_value == ZEND_FAST_RET_TO_CATCH) {
1385 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
1386 ZEND_VM_CONTINUE();
1387 } else if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
1388 return ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1389 } else {
1390 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1391 }
1392 }
1393 }
1394 }
1395
ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1396 static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1397 {
1398 USE_OPLINE
1399
1400 SAVE_OPLINE();
1401 if (EG(exception)) {
1402 zend_exception_save(TSRMLS_C);
1403 }
1404 if (IS_CONST == IS_UNUSED) {
1405 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1406 CHECK_EXCEPTION();
1407 ZEND_VM_NEXT_OPCODE();
1408 } else {
1409
1410 zval *class_name = opline->op2.zv;
1411
1412 if (IS_CONST == IS_CONST) {
1413 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1414 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
1415 } else {
1416 EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
1417 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
1418 }
1419 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
1420 EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
1421 } else if (Z_TYPE_P(class_name) == IS_STRING) {
1422 EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1423 } else {
1424 if (UNEXPECTED(EG(exception) != NULL)) {
1425 HANDLE_EXCEPTION();
1426 }
1427 zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1428 }
1429
1430 CHECK_EXCEPTION();
1431 ZEND_VM_NEXT_OPCODE();
1432 }
1433 }
1434
ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1435 static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1436 {
1437 USE_OPLINE
1438 zval *function_name;
1439 call_slot *call = EX(call_slots) + opline->result.num;
1440
1441 if (IS_CONST == IS_CONST) {
1442 function_name = (zval*)(opline->op2.literal+1);
1443 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1444 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
1445 } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
1446 SAVE_OPLINE();
1447 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
1448 } else {
1449 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
1450 }
1451
1452 call->object = NULL;
1453 call->called_scope = NULL;
1454 call->num_additional_args = 0;
1455 call->is_ctor_call = 0;
1456 EX(call) = call;
1457
1458 /*CHECK_EXCEPTION();*/
1459 ZEND_VM_NEXT_OPCODE();
1460 } else {
1461 char *function_name_strval, *lcname;
1462 int function_name_strlen;
1463
1464
1465 SAVE_OPLINE();
1466 function_name = opline->op2.zv;
1467
1468 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
1469 function_name_strval = Z_STRVAL_P(function_name);
1470 function_name_strlen = Z_STRLEN_P(function_name);
1471 if (function_name_strval[0] == '\\') {
1472 function_name_strlen -= 1;
1473 lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
1474 } else {
1475 lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
1476 }
1477 if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
1478 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
1479 }
1480 efree(lcname);
1481
1482 call->object = NULL;
1483 call->called_scope = NULL;
1484 call->num_additional_args = 0;
1485 call->is_ctor_call = 0;
1486 EX(call) = call;
1487
1488 CHECK_EXCEPTION();
1489 ZEND_VM_NEXT_OPCODE();
1490 } else if (IS_CONST != IS_CONST && IS_CONST != IS_TMP_VAR &&
1491 EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
1492 Z_OBJ_HANDLER_P(function_name, get_closure) &&
1493 Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
1494 if (call->object) {
1495 Z_ADDREF_P(call->object);
1496 }
1497 if (IS_CONST == IS_VAR && 0 && Z_REFCOUNT_P(function_name) == 1 &&
1498 call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
1499 /* Delay closure destruction until its invocation */
1500 call->fbc->common.prototype = (zend_function*)function_name;
1501 } else {
1502
1503 }
1504
1505 call->num_additional_args = 0;
1506 call->is_ctor_call = 0;
1507 EX(call) = call;
1508
1509 CHECK_EXCEPTION();
1510 ZEND_VM_NEXT_OPCODE();
1511 } else if (IS_CONST != IS_CONST &&
1512 EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
1513 zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
1514 zend_class_entry *ce;
1515 zval **method = NULL;
1516 zval **obj = NULL;
1517
1518 zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
1519 zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
1520
1521 if (!obj || !method) {
1522 zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
1523 }
1524
1525 if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
1526 zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
1527 }
1528
1529 if (Z_TYPE_PP(method) != IS_STRING) {
1530 zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
1531 }
1532
1533 if (Z_TYPE_PP(obj) == IS_STRING) {
1534 ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
1535 if (UNEXPECTED(ce == NULL)) {
1536 CHECK_EXCEPTION();
1537 ZEND_VM_NEXT_OPCODE();
1538 }
1539 call->called_scope = ce;
1540 call->object = NULL;
1541
1542 if (ce->get_static_method) {
1543 call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
1544 } else {
1545 call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
1546 }
1547 } else {
1548 call->object = *obj;
1549 ce = call->called_scope = Z_OBJCE_PP(obj);
1550
1551 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
1552 if (UNEXPECTED(call->fbc == NULL)) {
1553 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
1554 }
1555
1556 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
1557 call->object = NULL;
1558 } else {
1559 if (!PZVAL_IS_REF(call->object)) {
1560 Z_ADDREF_P(call->object); /* For $this pointer */
1561 } else {
1562 zval *this_ptr;
1563 ALLOC_ZVAL(this_ptr);
1564 INIT_PZVAL_COPY(this_ptr, call->object);
1565 zval_copy_ctor(this_ptr);
1566 call->object = this_ptr;
1567 }
1568 }
1569 }
1570
1571 if (UNEXPECTED(call->fbc == NULL)) {
1572 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
1573 }
1574
1575 call->num_additional_args = 0;
1576 call->is_ctor_call = 0;
1577 EX(call) = call;
1578
1579 CHECK_EXCEPTION();
1580 ZEND_VM_NEXT_OPCODE();
1581 } else {
1582 if (UNEXPECTED(EG(exception) != NULL)) {
1583 HANDLE_EXCEPTION();
1584 }
1585 zend_error_noreturn(E_ERROR, "Function name must be a string");
1586 ZEND_VM_NEXT_OPCODE(); /* Never reached */
1587 }
1588 }
1589 }
1590
1591
ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1592 static int ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1593 {
1594 USE_OPLINE
1595 zend_literal *func_name;
1596 call_slot *call = EX(call_slots) + opline->result.num;
1597
1598 func_name = opline->op2.literal + 1;
1599 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1600 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
1601 } else if (zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE) {
1602 func_name++;
1603 if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE)) {
1604 SAVE_OPLINE();
1605 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
1606 } else {
1607 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
1608 }
1609 } else {
1610 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
1611 }
1612
1613 call->object = NULL;
1614 call->called_scope = NULL;
1615 call->num_additional_args = 0;
1616 call->is_ctor_call = 0;
1617
1618 EX(call) = call;
1619 ZEND_VM_NEXT_OPCODE();
1620 }
1621
ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1622 static int ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1623 {
1624 USE_OPLINE
1625 zval *assignment_value;
1626 zend_uint arg_num = opline->op1.num;
1627 zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
1628 zval **var_ptr;
1629
1630 SAVE_OPLINE();
1631 if (param == NULL) {
1632 ALLOC_ZVAL(assignment_value);
1633 *assignment_value = *opline->op2.zv;
1634 if (IS_CONSTANT_TYPE(Z_TYPE_P(assignment_value))) {
1635 Z_SET_REFCOUNT_P(assignment_value, 1);
1636 zval_update_constant(&assignment_value, 0 TSRMLS_CC);
1637 } else if (Z_TYPE_P(assignment_value) == IS_ARRAY) {
1638 HashTable *ht;
1639
1640 ALLOC_HASHTABLE(ht);
1641 zend_hash_init(ht, zend_hash_num_elements(Z_ARRVAL_P(assignment_value)), NULL, ZVAL_PTR_DTOR, 0);
1642 zend_hash_copy(ht, Z_ARRVAL_P(assignment_value), (copy_ctor_func_t) zval_deep_copy, NULL, sizeof(zval *));
1643 Z_ARRVAL_P(assignment_value) = ht;
1644 } else {
1645 zval_copy_ctor(assignment_value);
1646 }
1647 INIT_PZVAL(assignment_value);
1648 } else {
1649 assignment_value = *param;
1650 Z_ADDREF_P(assignment_value);
1651 }
1652
1653 zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value, opline->extended_value, opline->op2.zv TSRMLS_CC);
1654 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
1655 zval_ptr_dtor(var_ptr);
1656 *var_ptr = assignment_value;
1657
1658 CHECK_EXCEPTION();
1659 ZEND_VM_NEXT_OPCODE();
1660 }
1661
ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1662 static int ZEND_FASTCALL ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1663 {
1664 USE_OPLINE
1665 zend_brk_cont_element *el;
1666
1667 SAVE_OPLINE();
1668 el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num,
1669 EX(op_array), execute_data TSRMLS_CC);
1670 ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
1671 }
1672
ZEND_CONT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1673 static int ZEND_FASTCALL ZEND_CONT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1674 {
1675 USE_OPLINE
1676 zend_brk_cont_element *el;
1677
1678 SAVE_OPLINE();
1679 el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num,
1680 EX(op_array), execute_data TSRMLS_CC);
1681 ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
1682 }
1683
ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1684 static int ZEND_FASTCALL ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1685 {
1686 zend_op *brk_opline;
1687 USE_OPLINE
1688 zend_brk_cont_element *el;
1689
1690 SAVE_OPLINE();
1691 el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->extended_value,
1692 EX(op_array), execute_data TSRMLS_CC);
1693
1694 brk_opline = EX(op_array)->opcodes + el->brk;
1695
1696 switch (brk_opline->opcode) {
1697 case ZEND_SWITCH_FREE:
1698 if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
1699 zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
1700 }
1701 break;
1702 case ZEND_FREE:
1703 if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
1704 zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
1705 }
1706 break;
1707 }
1708 ZEND_VM_JMP(opline->op1.jmp_addr);
1709 }
1710
ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1711 static int ZEND_FASTCALL ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1712 {
1713 USE_OPLINE
1714 zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
1715 zend_class_entry *iface;
1716
1717 SAVE_OPLINE();
1718 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1719 iface = CACHED_PTR(opline->op2.literal->cache_slot);
1720 } else {
1721 iface = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
1722 if (UNEXPECTED(iface == NULL)) {
1723 CHECK_EXCEPTION();
1724 ZEND_VM_NEXT_OPCODE();
1725 }
1726 CACHE_PTR(opline->op2.literal->cache_slot, iface);
1727 }
1728
1729 if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
1730 zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
1731 }
1732 zend_do_implement_interface(ce, iface TSRMLS_CC);
1733
1734 CHECK_EXCEPTION();
1735 ZEND_VM_NEXT_OPCODE();
1736 }
1737
ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1738 static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1739 {
1740 USE_OPLINE
1741
1742 SAVE_OPLINE();
1743 if (EG(exception)) {
1744 zend_exception_save(TSRMLS_C);
1745 }
1746 if (IS_TMP_VAR == IS_UNUSED) {
1747 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1748 CHECK_EXCEPTION();
1749 ZEND_VM_NEXT_OPCODE();
1750 } else {
1751 zend_free_op free_op2;
1752 zval *class_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
1753
1754 if (IS_TMP_VAR == IS_CONST) {
1755 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1756 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
1757 } else {
1758 EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
1759 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
1760 }
1761 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
1762 EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
1763 } else if (Z_TYPE_P(class_name) == IS_STRING) {
1764 EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1765 } else {
1766 if (UNEXPECTED(EG(exception) != NULL)) {
1767 HANDLE_EXCEPTION();
1768 }
1769 zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1770 }
1771
1772 zval_dtor(free_op2.var);
1773 CHECK_EXCEPTION();
1774 ZEND_VM_NEXT_OPCODE();
1775 }
1776 }
1777
ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1778 static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1779 {
1780 USE_OPLINE
1781 zval *function_name;
1782 call_slot *call = EX(call_slots) + opline->result.num;
1783
1784 if (IS_TMP_VAR == IS_CONST) {
1785 function_name = (zval*)(opline->op2.literal+1);
1786 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1787 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
1788 } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
1789 SAVE_OPLINE();
1790 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
1791 } else {
1792 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
1793 }
1794
1795 call->object = NULL;
1796 call->called_scope = NULL;
1797 call->num_additional_args = 0;
1798 call->is_ctor_call = 0;
1799 EX(call) = call;
1800
1801 /*CHECK_EXCEPTION();*/
1802 ZEND_VM_NEXT_OPCODE();
1803 } else {
1804 char *function_name_strval, *lcname;
1805 int function_name_strlen;
1806 zend_free_op free_op2;
1807
1808 SAVE_OPLINE();
1809 function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
1810
1811 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
1812 function_name_strval = Z_STRVAL_P(function_name);
1813 function_name_strlen = Z_STRLEN_P(function_name);
1814 if (function_name_strval[0] == '\\') {
1815 function_name_strlen -= 1;
1816 lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
1817 } else {
1818 lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
1819 }
1820 if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
1821 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
1822 }
1823 efree(lcname);
1824 zval_dtor(free_op2.var);
1825
1826 call->object = NULL;
1827 call->called_scope = NULL;
1828 call->num_additional_args = 0;
1829 call->is_ctor_call = 0;
1830 EX(call) = call;
1831
1832 CHECK_EXCEPTION();
1833 ZEND_VM_NEXT_OPCODE();
1834 } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_TMP_VAR &&
1835 EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
1836 Z_OBJ_HANDLER_P(function_name, get_closure) &&
1837 Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
1838 if (call->object) {
1839 Z_ADDREF_P(call->object);
1840 }
1841 if (IS_TMP_VAR == IS_VAR && 1 && Z_REFCOUNT_P(function_name) == 1 &&
1842 call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
1843 /* Delay closure destruction until its invocation */
1844 call->fbc->common.prototype = (zend_function*)function_name;
1845 } else {
1846 zval_dtor(free_op2.var);
1847 }
1848
1849 call->num_additional_args = 0;
1850 call->is_ctor_call = 0;
1851 EX(call) = call;
1852
1853 CHECK_EXCEPTION();
1854 ZEND_VM_NEXT_OPCODE();
1855 } else if (IS_TMP_VAR != IS_CONST &&
1856 EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
1857 zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
1858 zend_class_entry *ce;
1859 zval **method = NULL;
1860 zval **obj = NULL;
1861
1862 zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
1863 zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
1864
1865 if (!obj || !method) {
1866 zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
1867 }
1868
1869 if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
1870 zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
1871 }
1872
1873 if (Z_TYPE_PP(method) != IS_STRING) {
1874 zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
1875 }
1876
1877 if (Z_TYPE_PP(obj) == IS_STRING) {
1878 ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
1879 if (UNEXPECTED(ce == NULL)) {
1880 CHECK_EXCEPTION();
1881 ZEND_VM_NEXT_OPCODE();
1882 }
1883 call->called_scope = ce;
1884 call->object = NULL;
1885
1886 if (ce->get_static_method) {
1887 call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
1888 } else {
1889 call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
1890 }
1891 } else {
1892 call->object = *obj;
1893 ce = call->called_scope = Z_OBJCE_PP(obj);
1894
1895 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
1896 if (UNEXPECTED(call->fbc == NULL)) {
1897 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
1898 }
1899
1900 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
1901 call->object = NULL;
1902 } else {
1903 if (!PZVAL_IS_REF(call->object)) {
1904 Z_ADDREF_P(call->object); /* For $this pointer */
1905 } else {
1906 zval *this_ptr;
1907 ALLOC_ZVAL(this_ptr);
1908 INIT_PZVAL_COPY(this_ptr, call->object);
1909 zval_copy_ctor(this_ptr);
1910 call->object = this_ptr;
1911 }
1912 }
1913 }
1914
1915 if (UNEXPECTED(call->fbc == NULL)) {
1916 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
1917 }
1918
1919 call->num_additional_args = 0;
1920 call->is_ctor_call = 0;
1921 EX(call) = call;
1922
1923 zval_dtor(free_op2.var);
1924 CHECK_EXCEPTION();
1925 ZEND_VM_NEXT_OPCODE();
1926 } else {
1927 if (UNEXPECTED(EG(exception) != NULL)) {
1928 HANDLE_EXCEPTION();
1929 }
1930 zend_error_noreturn(E_ERROR, "Function name must be a string");
1931 ZEND_VM_NEXT_OPCODE(); /* Never reached */
1932 }
1933 }
1934 }
1935
1936
ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1937 static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1938 {
1939 USE_OPLINE
1940
1941 SAVE_OPLINE();
1942 if (EG(exception)) {
1943 zend_exception_save(TSRMLS_C);
1944 }
1945 if (IS_VAR == IS_UNUSED) {
1946 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1947 CHECK_EXCEPTION();
1948 ZEND_VM_NEXT_OPCODE();
1949 } else {
1950 zend_free_op free_op2;
1951 zval *class_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
1952
1953 if (IS_VAR == IS_CONST) {
1954 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1955 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
1956 } else {
1957 EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
1958 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
1959 }
1960 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
1961 EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
1962 } else if (Z_TYPE_P(class_name) == IS_STRING) {
1963 EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1964 } else {
1965 if (UNEXPECTED(EG(exception) != NULL)) {
1966 HANDLE_EXCEPTION();
1967 }
1968 zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1969 }
1970
1971 zval_ptr_dtor_nogc(&free_op2.var);
1972 CHECK_EXCEPTION();
1973 ZEND_VM_NEXT_OPCODE();
1974 }
1975 }
1976
ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1977 static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1978 {
1979 USE_OPLINE
1980 zval *function_name;
1981 call_slot *call = EX(call_slots) + opline->result.num;
1982
1983 if (IS_VAR == IS_CONST) {
1984 function_name = (zval*)(opline->op2.literal+1);
1985 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1986 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
1987 } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
1988 SAVE_OPLINE();
1989 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
1990 } else {
1991 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
1992 }
1993
1994 call->object = NULL;
1995 call->called_scope = NULL;
1996 call->num_additional_args = 0;
1997 call->is_ctor_call = 0;
1998 EX(call) = call;
1999
2000 /*CHECK_EXCEPTION();*/
2001 ZEND_VM_NEXT_OPCODE();
2002 } else {
2003 char *function_name_strval, *lcname;
2004 int function_name_strlen;
2005 zend_free_op free_op2;
2006
2007 SAVE_OPLINE();
2008 function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
2009
2010 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
2011 function_name_strval = Z_STRVAL_P(function_name);
2012 function_name_strlen = Z_STRLEN_P(function_name);
2013 if (function_name_strval[0] == '\\') {
2014 function_name_strlen -= 1;
2015 lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
2016 } else {
2017 lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
2018 }
2019 if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
2020 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
2021 }
2022 efree(lcname);
2023 zval_ptr_dtor_nogc(&free_op2.var);
2024
2025 call->object = NULL;
2026 call->called_scope = NULL;
2027 call->num_additional_args = 0;
2028 call->is_ctor_call = 0;
2029 EX(call) = call;
2030
2031 CHECK_EXCEPTION();
2032 ZEND_VM_NEXT_OPCODE();
2033 } else if (IS_VAR != IS_CONST && IS_VAR != IS_TMP_VAR &&
2034 EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
2035 Z_OBJ_HANDLER_P(function_name, get_closure) &&
2036 Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
2037 if (call->object) {
2038 Z_ADDREF_P(call->object);
2039 }
2040 if (IS_VAR == IS_VAR && (free_op2.var != NULL) && Z_REFCOUNT_P(function_name) == 1 &&
2041 call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
2042 /* Delay closure destruction until its invocation */
2043 call->fbc->common.prototype = (zend_function*)function_name;
2044 } else {
2045 zval_ptr_dtor_nogc(&free_op2.var);
2046 }
2047
2048 call->num_additional_args = 0;
2049 call->is_ctor_call = 0;
2050 EX(call) = call;
2051
2052 CHECK_EXCEPTION();
2053 ZEND_VM_NEXT_OPCODE();
2054 } else if (IS_VAR != IS_CONST &&
2055 EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
2056 zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
2057 zend_class_entry *ce;
2058 zval **method = NULL;
2059 zval **obj = NULL;
2060
2061 zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
2062 zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
2063
2064 if (!obj || !method) {
2065 zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
2066 }
2067
2068 if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
2069 zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
2070 }
2071
2072 if (Z_TYPE_PP(method) != IS_STRING) {
2073 zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
2074 }
2075
2076 if (Z_TYPE_PP(obj) == IS_STRING) {
2077 ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
2078 if (UNEXPECTED(ce == NULL)) {
2079 CHECK_EXCEPTION();
2080 ZEND_VM_NEXT_OPCODE();
2081 }
2082 call->called_scope = ce;
2083 call->object = NULL;
2084
2085 if (ce->get_static_method) {
2086 call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
2087 } else {
2088 call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
2089 }
2090 } else {
2091 call->object = *obj;
2092 ce = call->called_scope = Z_OBJCE_PP(obj);
2093
2094 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
2095 if (UNEXPECTED(call->fbc == NULL)) {
2096 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
2097 }
2098
2099 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
2100 call->object = NULL;
2101 } else {
2102 if (!PZVAL_IS_REF(call->object)) {
2103 Z_ADDREF_P(call->object); /* For $this pointer */
2104 } else {
2105 zval *this_ptr;
2106 ALLOC_ZVAL(this_ptr);
2107 INIT_PZVAL_COPY(this_ptr, call->object);
2108 zval_copy_ctor(this_ptr);
2109 call->object = this_ptr;
2110 }
2111 }
2112 }
2113
2114 if (UNEXPECTED(call->fbc == NULL)) {
2115 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
2116 }
2117
2118 call->num_additional_args = 0;
2119 call->is_ctor_call = 0;
2120 EX(call) = call;
2121
2122 zval_ptr_dtor_nogc(&free_op2.var);
2123 CHECK_EXCEPTION();
2124 ZEND_VM_NEXT_OPCODE();
2125 } else {
2126 if (UNEXPECTED(EG(exception) != NULL)) {
2127 HANDLE_EXCEPTION();
2128 }
2129 zend_error_noreturn(E_ERROR, "Function name must be a string");
2130 ZEND_VM_NEXT_OPCODE(); /* Never reached */
2131 }
2132 }
2133 }
2134
2135
ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2136 static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2137 {
2138 USE_OPLINE
2139
2140 SAVE_OPLINE();
2141 if (EG(exception)) {
2142 zend_exception_save(TSRMLS_C);
2143 }
2144 if (IS_UNUSED == IS_UNUSED) {
2145 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
2146 CHECK_EXCEPTION();
2147 ZEND_VM_NEXT_OPCODE();
2148 } else {
2149
2150 zval *class_name = NULL;
2151
2152 if (IS_UNUSED == IS_CONST) {
2153 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
2154 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
2155 } else {
2156 EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
2157 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
2158 }
2159 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
2160 EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
2161 } else if (Z_TYPE_P(class_name) == IS_STRING) {
2162 EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
2163 } else {
2164 if (UNEXPECTED(EG(exception) != NULL)) {
2165 HANDLE_EXCEPTION();
2166 }
2167 zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
2168 }
2169
2170 CHECK_EXCEPTION();
2171 ZEND_VM_NEXT_OPCODE();
2172 }
2173 }
2174
ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2175 static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2176 {
2177 USE_OPLINE
2178
2179 SAVE_OPLINE();
2180 if (EG(exception)) {
2181 zend_exception_save(TSRMLS_C);
2182 }
2183 if (IS_CV == IS_UNUSED) {
2184 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
2185 CHECK_EXCEPTION();
2186 ZEND_VM_NEXT_OPCODE();
2187 } else {
2188
2189 zval *class_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
2190
2191 if (IS_CV == IS_CONST) {
2192 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
2193 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
2194 } else {
2195 EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
2196 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
2197 }
2198 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
2199 EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
2200 } else if (Z_TYPE_P(class_name) == IS_STRING) {
2201 EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
2202 } else {
2203 if (UNEXPECTED(EG(exception) != NULL)) {
2204 HANDLE_EXCEPTION();
2205 }
2206 zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
2207 }
2208
2209 CHECK_EXCEPTION();
2210 ZEND_VM_NEXT_OPCODE();
2211 }
2212 }
2213
ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2214 static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2215 {
2216 USE_OPLINE
2217 zval *function_name;
2218 call_slot *call = EX(call_slots) + opline->result.num;
2219
2220 if (IS_CV == IS_CONST) {
2221 function_name = (zval*)(opline->op2.literal+1);
2222 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
2223 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
2224 } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
2225 SAVE_OPLINE();
2226 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
2227 } else {
2228 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
2229 }
2230
2231 call->object = NULL;
2232 call->called_scope = NULL;
2233 call->num_additional_args = 0;
2234 call->is_ctor_call = 0;
2235 EX(call) = call;
2236
2237 /*CHECK_EXCEPTION();*/
2238 ZEND_VM_NEXT_OPCODE();
2239 } else {
2240 char *function_name_strval, *lcname;
2241 int function_name_strlen;
2242
2243
2244 SAVE_OPLINE();
2245 function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
2246
2247 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
2248 function_name_strval = Z_STRVAL_P(function_name);
2249 function_name_strlen = Z_STRLEN_P(function_name);
2250 if (function_name_strval[0] == '\\') {
2251 function_name_strlen -= 1;
2252 lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
2253 } else {
2254 lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
2255 }
2256 if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
2257 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
2258 }
2259 efree(lcname);
2260
2261 call->object = NULL;
2262 call->called_scope = NULL;
2263 call->num_additional_args = 0;
2264 call->is_ctor_call = 0;
2265 EX(call) = call;
2266
2267 CHECK_EXCEPTION();
2268 ZEND_VM_NEXT_OPCODE();
2269 } else if (IS_CV != IS_CONST && IS_CV != IS_TMP_VAR &&
2270 EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
2271 Z_OBJ_HANDLER_P(function_name, get_closure) &&
2272 Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
2273 if (call->object) {
2274 Z_ADDREF_P(call->object);
2275 }
2276 if (IS_CV == IS_VAR && 0 && Z_REFCOUNT_P(function_name) == 1 &&
2277 call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
2278 /* Delay closure destruction until its invocation */
2279 call->fbc->common.prototype = (zend_function*)function_name;
2280 } else {
2281
2282 }
2283
2284 call->num_additional_args = 0;
2285 call->is_ctor_call = 0;
2286 EX(call) = call;
2287
2288 CHECK_EXCEPTION();
2289 ZEND_VM_NEXT_OPCODE();
2290 } else if (IS_CV != IS_CONST &&
2291 EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
2292 zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
2293 zend_class_entry *ce;
2294 zval **method = NULL;
2295 zval **obj = NULL;
2296
2297 zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
2298 zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
2299
2300 if (!obj || !method) {
2301 zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
2302 }
2303
2304 if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
2305 zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
2306 }
2307
2308 if (Z_TYPE_PP(method) != IS_STRING) {
2309 zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
2310 }
2311
2312 if (Z_TYPE_PP(obj) == IS_STRING) {
2313 ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
2314 if (UNEXPECTED(ce == NULL)) {
2315 CHECK_EXCEPTION();
2316 ZEND_VM_NEXT_OPCODE();
2317 }
2318 call->called_scope = ce;
2319 call->object = NULL;
2320
2321 if (ce->get_static_method) {
2322 call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
2323 } else {
2324 call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
2325 }
2326 } else {
2327 call->object = *obj;
2328 ce = call->called_scope = Z_OBJCE_PP(obj);
2329
2330 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
2331 if (UNEXPECTED(call->fbc == NULL)) {
2332 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
2333 }
2334
2335 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
2336 call->object = NULL;
2337 } else {
2338 if (!PZVAL_IS_REF(call->object)) {
2339 Z_ADDREF_P(call->object); /* For $this pointer */
2340 } else {
2341 zval *this_ptr;
2342 ALLOC_ZVAL(this_ptr);
2343 INIT_PZVAL_COPY(this_ptr, call->object);
2344 zval_copy_ctor(this_ptr);
2345 call->object = this_ptr;
2346 }
2347 }
2348 }
2349
2350 if (UNEXPECTED(call->fbc == NULL)) {
2351 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
2352 }
2353
2354 call->num_additional_args = 0;
2355 call->is_ctor_call = 0;
2356 EX(call) = call;
2357
2358 CHECK_EXCEPTION();
2359 ZEND_VM_NEXT_OPCODE();
2360 } else {
2361 if (UNEXPECTED(EG(exception) != NULL)) {
2362 HANDLE_EXCEPTION();
2363 }
2364 zend_error_noreturn(E_ERROR, "Function name must be a string");
2365 ZEND_VM_NEXT_OPCODE(); /* Never reached */
2366 }
2367 }
2368 }
2369
2370
ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2371 static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2372 {
2373 USE_OPLINE
2374
2375
2376 SAVE_OPLINE();
2377 bitwise_not_function(&EX_T(opline->result.var).tmp_var,
2378 opline->op1.zv TSRMLS_CC);
2379
2380 CHECK_EXCEPTION();
2381 ZEND_VM_NEXT_OPCODE();
2382 }
2383
ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2384 static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2385 {
2386 USE_OPLINE
2387
2388
2389 SAVE_OPLINE();
2390 boolean_not_function(&EX_T(opline->result.var).tmp_var,
2391 opline->op1.zv TSRMLS_CC);
2392
2393 CHECK_EXCEPTION();
2394 ZEND_VM_NEXT_OPCODE();
2395 }
2396
ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2397 static int ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2398 {
2399 USE_OPLINE
2400
2401 zval *z;
2402
2403 SAVE_OPLINE();
2404 z = opline->op1.zv;
2405
2406 if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
2407 INIT_PZVAL(z);
2408 }
2409 zend_print_variable(z);
2410
2411 CHECK_EXCEPTION();
2412 ZEND_VM_NEXT_OPCODE();
2413 }
2414
ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2415 static int ZEND_FASTCALL ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2416 {
2417 USE_OPLINE
2418
2419 ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
2420 return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2421 }
2422
ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2423 static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2424 {
2425 USE_OPLINE
2426
2427 zval *val;
2428 int ret;
2429
2430 SAVE_OPLINE();
2431 val = opline->op1.zv;
2432
2433 if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2434 ret = Z_LVAL_P(val);
2435 } else {
2436 ret = i_zend_is_true(val);
2437
2438 if (UNEXPECTED(EG(exception) != NULL)) {
2439 HANDLE_EXCEPTION();
2440 }
2441 }
2442 if (!ret) {
2443 #if DEBUG_ZEND>=2
2444 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2445 #endif
2446 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2447 ZEND_VM_CONTINUE();
2448 }
2449
2450 ZEND_VM_NEXT_OPCODE();
2451 }
2452
ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2453 static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2454 {
2455 USE_OPLINE
2456
2457 zval *val;
2458 int ret;
2459
2460 SAVE_OPLINE();
2461 val = opline->op1.zv;
2462
2463 if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2464 ret = Z_LVAL_P(val);
2465 } else {
2466 ret = i_zend_is_true(val);
2467
2468 if (UNEXPECTED(EG(exception) != NULL)) {
2469 HANDLE_EXCEPTION();
2470 }
2471 }
2472 if (ret) {
2473 #if DEBUG_ZEND>=2
2474 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2475 #endif
2476 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2477 ZEND_VM_CONTINUE();
2478 }
2479
2480 ZEND_VM_NEXT_OPCODE();
2481 }
2482
ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2483 static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2484 {
2485 USE_OPLINE
2486
2487 zval *val;
2488 int retval;
2489
2490 SAVE_OPLINE();
2491 val = opline->op1.zv;
2492
2493 if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2494 retval = Z_LVAL_P(val);
2495 } else {
2496 retval = i_zend_is_true(val);
2497
2498 if (UNEXPECTED(EG(exception) != NULL)) {
2499 HANDLE_EXCEPTION();
2500 }
2501 }
2502 if (EXPECTED(retval != 0)) {
2503 #if DEBUG_ZEND>=2
2504 printf("Conditional jmp on true to %d\n", opline->extended_value);
2505 #endif
2506 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
2507 ZEND_VM_CONTINUE(); /* CHECK_ME */
2508 } else {
2509 #if DEBUG_ZEND>=2
2510 printf("Conditional jmp on false to %d\n", opline->op2.opline_num);
2511 #endif
2512 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
2513 ZEND_VM_CONTINUE(); /* CHECK_ME */
2514 }
2515 }
2516
ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2517 static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2518 {
2519 USE_OPLINE
2520
2521 zval *val;
2522 int retval;
2523
2524 SAVE_OPLINE();
2525 val = opline->op1.zv;
2526
2527 if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2528 retval = Z_LVAL_P(val);
2529 } else {
2530 retval = i_zend_is_true(val);
2531
2532 if (UNEXPECTED(EG(exception) != NULL)) {
2533 HANDLE_EXCEPTION();
2534 }
2535 }
2536 Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
2537 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
2538 if (!retval) {
2539 #if DEBUG_ZEND>=2
2540 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2541 #endif
2542 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2543 ZEND_VM_CONTINUE();
2544 }
2545 ZEND_VM_NEXT_OPCODE();
2546 }
2547
ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2548 static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2549 {
2550 USE_OPLINE
2551
2552 zval *val;
2553 int retval;
2554
2555 SAVE_OPLINE();
2556 val = opline->op1.zv;
2557
2558 if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2559 retval = Z_LVAL_P(val);
2560 } else {
2561 retval = i_zend_is_true(val);
2562
2563 if (UNEXPECTED(EG(exception) != NULL)) {
2564 HANDLE_EXCEPTION();
2565 }
2566 }
2567 Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
2568 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
2569 if (retval) {
2570 #if DEBUG_ZEND>=2
2571 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2572 #endif
2573 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2574 ZEND_VM_CONTINUE();
2575 }
2576 ZEND_VM_NEXT_OPCODE();
2577 }
2578
ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2579 static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2580 {
2581 USE_OPLINE
2582
2583 zval *fname = opline->op1.zv;
2584 call_slot *call = EX(call_slots) + opline->op2.num;
2585
2586 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
2587 EX(function_state).function = CACHED_PTR(opline->op1.literal->cache_slot);
2588 } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(fname), Z_STRLEN_P(fname)+1, Z_HASH_P(fname), (void **) &EX(function_state).function)==FAILURE)) {
2589 SAVE_OPLINE();
2590 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
2591 } else {
2592 CACHE_PTR(opline->op1.literal->cache_slot, EX(function_state).function);
2593 }
2594
2595 call->fbc = EX(function_state).function;
2596 call->object = NULL;
2597 call->called_scope = NULL;
2598 call->num_additional_args = 0;
2599 call->is_ctor_call = 0;
2600 EX(call) = call;
2601
2602 return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2603 }
2604
ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2605 static int ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2606 {
2607 USE_OPLINE
2608 zval *retval_ptr;
2609
2610
2611 SAVE_OPLINE();
2612 retval_ptr = opline->op1.zv;
2613
2614 if (!EG(return_value_ptr_ptr)) {
2615
2616 } else {
2617 if (IS_CONST == IS_CONST ||
2618 IS_CONST == IS_TMP_VAR ||
2619 PZVAL_IS_REF(retval_ptr)) {
2620 zval *ret;
2621
2622 ALLOC_ZVAL(ret);
2623 INIT_PZVAL_COPY(ret, retval_ptr);
2624 if (IS_CONST != IS_TMP_VAR) {
2625 zval_copy_ctor(ret);
2626 }
2627 *EG(return_value_ptr_ptr) = ret;
2628
2629 } else if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) &&
2630 retval_ptr == &EG(uninitialized_zval)) {
2631 zval *ret;
2632
2633 if (IS_CONST == IS_VAR) {
2634 Z_DELREF_P(retval_ptr);
2635 }
2636 ALLOC_INIT_ZVAL(ret);
2637 *EG(return_value_ptr_ptr) = ret;
2638 } else {
2639 *EG(return_value_ptr_ptr) = retval_ptr;
2640 if (IS_CONST == IS_CV) {
2641 Z_ADDREF_P(retval_ptr);
2642 }
2643 }
2644 }
2645 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2646 }
2647
ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2648 static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2649 {
2650 USE_OPLINE
2651 zval *retval_ptr;
2652 zval **retval_ptr_ptr;
2653
2654
2655 SAVE_OPLINE();
2656
2657 do {
2658 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR ||
2659 (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
2660 /* Not supposed to happen, but we'll allow it */
2661 zend_error(E_NOTICE, "Only variable references should be returned by reference");
2662
2663 retval_ptr = opline->op1.zv;
2664 if (!EG(return_value_ptr_ptr)) {
2665 if (IS_CONST == IS_TMP_VAR) {
2666
2667 }
2668 } else if (!0) { /* Not a temp var */
2669 zval *ret;
2670
2671 ALLOC_ZVAL(ret);
2672 INIT_PZVAL_COPY(ret, retval_ptr);
2673 zval_copy_ctor(ret);
2674 *EG(return_value_ptr_ptr) = ret;
2675 } else {
2676 zval *ret;
2677
2678 ALLOC_ZVAL(ret);
2679 INIT_PZVAL_COPY(ret, retval_ptr);
2680 *EG(return_value_ptr_ptr) = ret;
2681 }
2682 break;
2683 }
2684
2685 retval_ptr_ptr = NULL;
2686
2687 if (IS_CONST == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
2688 zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
2689 }
2690
2691 if (IS_CONST == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
2692 if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
2693 EX_T(opline->op1.var).var.fcall_returned_reference) {
2694 } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
2695 zend_error(E_NOTICE, "Only variable references should be returned by reference");
2696 if (EG(return_value_ptr_ptr)) {
2697 zval *ret;
2698
2699 ALLOC_ZVAL(ret);
2700 INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
2701 zval_copy_ctor(ret);
2702 *EG(return_value_ptr_ptr) = ret;
2703 }
2704 break;
2705 }
2706 }
2707
2708 if (EG(return_value_ptr_ptr)) {
2709 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
2710 Z_ADDREF_PP(retval_ptr_ptr);
2711
2712 *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
2713 }
2714 } while (0);
2715
2716 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2717 }
2718
ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2719 static int ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2720 {
2721 USE_OPLINE
2722 zval *value;
2723 zval *exception;
2724
2725
2726 SAVE_OPLINE();
2727 value = opline->op1.zv;
2728
2729 if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
2730 if (UNEXPECTED(EG(exception) != NULL)) {
2731 HANDLE_EXCEPTION();
2732 }
2733 zend_error_noreturn(E_ERROR, "Can only throw objects");
2734 }
2735
2736 zend_exception_save(TSRMLS_C);
2737 /* Not sure if a complete copy is what we want here */
2738 ALLOC_ZVAL(exception);
2739 INIT_PZVAL_COPY(exception, value);
2740 if (!0) {
2741 zval_copy_ctor(exception);
2742 }
2743
2744 zend_throw_exception_object(exception TSRMLS_CC);
2745 zend_exception_restore(TSRMLS_C);
2746
2747 HANDLE_EXCEPTION();
2748 }
2749
ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2750 static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2751 {
2752 USE_OPLINE
2753
2754 SAVE_OPLINE();
2755 if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
2756 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
2757 zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.num);
2758 }
2759 }
2760
2761 {
2762 zval *valptr;
2763 zval *value;
2764
2765
2766 value = opline->op1.zv;
2767
2768 ALLOC_ZVAL(valptr);
2769 INIT_PZVAL_COPY(valptr, value);
2770 if (!0) {
2771 zval_copy_ctor(valptr);
2772 }
2773 zend_vm_stack_push(valptr TSRMLS_CC);
2774
2775 }
2776 CHECK_EXCEPTION();
2777 ZEND_VM_NEXT_OPCODE();
2778 }
2779
ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2780 static int ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2781 {
2782 USE_OPLINE
2783
2784 zval *retval = &EX_T(opline->result.var).tmp_var;
2785
2786 SAVE_OPLINE();
2787 /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
2788 ZVAL_BOOL(retval, i_zend_is_true(opline->op1.zv));
2789
2790 CHECK_EXCEPTION();
2791 ZEND_VM_NEXT_OPCODE();
2792 }
2793
ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2794 static int ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2795 {
2796 USE_OPLINE
2797
2798 zval *obj;
2799 zend_class_entry *ce;
2800 zend_function *clone;
2801 zend_object_clone_obj_t clone_call;
2802
2803 SAVE_OPLINE();
2804 obj = opline->op1.zv;
2805
2806 if (IS_CONST == IS_CONST ||
2807 UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
2808 if (UNEXPECTED(EG(exception) != NULL)) {
2809 HANDLE_EXCEPTION();
2810 }
2811 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
2812 }
2813
2814 ce = Z_OBJCE_P(obj);
2815 clone = ce ? ce->clone : NULL;
2816 clone_call = Z_OBJ_HT_P(obj)->clone_obj;
2817 if (UNEXPECTED(clone_call == NULL)) {
2818 if (ce) {
2819 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
2820 } else {
2821 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
2822 }
2823 }
2824
2825 if (ce && clone) {
2826 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
2827 /* Ensure that if we're calling a private function, we're allowed to do so.
2828 */
2829 if (UNEXPECTED(ce != EG(scope))) {
2830 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
2831 }
2832 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
2833 /* Ensure that if we're calling a protected function, we're allowed to do so.
2834 */
2835 if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
2836 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
2837 }
2838 }
2839 }
2840
2841 if (EXPECTED(EG(exception) == NULL)) {
2842 zval *retval;
2843
2844 ALLOC_ZVAL(retval);
2845 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
2846 Z_TYPE_P(retval) = IS_OBJECT;
2847 Z_SET_REFCOUNT_P(retval, 1);
2848 Z_SET_ISREF_P(retval);
2849 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
2850 zval_ptr_dtor(&retval);
2851 } else {
2852 EX_T(opline->result.var).var.ptr = retval;
2853 }
2854 }
2855
2856 CHECK_EXCEPTION();
2857 ZEND_VM_NEXT_OPCODE();
2858 }
2859
ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2860 static int ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2861 {
2862 USE_OPLINE
2863
2864 zval *expr;
2865 zval *result = &EX_T(opline->result.var).tmp_var;
2866
2867 SAVE_OPLINE();
2868 expr = opline->op1.zv;
2869
2870 if (opline->extended_value != IS_STRING) {
2871 ZVAL_COPY_VALUE(result, expr);
2872 if (!0) {
2873 zendi_zval_copy_ctor(*result);
2874 }
2875 }
2876 switch (opline->extended_value) {
2877 case IS_NULL:
2878 convert_to_null(result);
2879 break;
2880 case IS_BOOL:
2881 convert_to_boolean(result);
2882 break;
2883 case IS_LONG:
2884 convert_to_long(result);
2885 break;
2886 case IS_DOUBLE:
2887 convert_to_double(result);
2888 break;
2889 case IS_STRING: {
2890 zval var_copy;
2891 int use_copy;
2892
2893 zend_make_printable_zval(expr, &var_copy, &use_copy);
2894 if (use_copy) {
2895 ZVAL_COPY_VALUE(result, &var_copy);
2896 if (0) {
2897
2898 }
2899 } else {
2900 ZVAL_COPY_VALUE(result, expr);
2901 if (!0) {
2902 zendi_zval_copy_ctor(*result);
2903 }
2904 }
2905 break;
2906 }
2907 case IS_ARRAY:
2908 convert_to_array(result);
2909 break;
2910 case IS_OBJECT:
2911 convert_to_object(result);
2912 break;
2913 }
2914
2915 CHECK_EXCEPTION();
2916 ZEND_VM_NEXT_OPCODE();
2917 }
2918
ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2919 static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2920 {
2921 USE_OPLINE
2922 zend_op_array *new_op_array=NULL;
2923
2924 zval *inc_filename;
2925 zval *tmp_inc_filename = NULL;
2926 zend_bool failure_retval=0;
2927
2928 SAVE_OPLINE();
2929 inc_filename = opline->op1.zv;
2930
2931 if (inc_filename->type!=IS_STRING) {
2932 MAKE_STD_ZVAL(tmp_inc_filename);
2933 ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
2934 zval_copy_ctor(tmp_inc_filename);
2935 convert_to_string(tmp_inc_filename);
2936 inc_filename = tmp_inc_filename;
2937 }
2938
2939 if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
2940 if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
2941 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
2942 } else {
2943 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
2944 }
2945 } else {
2946 switch (opline->extended_value) {
2947 case ZEND_INCLUDE_ONCE:
2948 case ZEND_REQUIRE_ONCE: {
2949 zend_file_handle file_handle;
2950 char *resolved_path;
2951
2952 resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
2953 if (resolved_path) {
2954 failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
2955 } else {
2956 resolved_path = Z_STRVAL_P(inc_filename);
2957 }
2958
2959 if (failure_retval) {
2960 /* do nothing, file already included */
2961 } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
2962
2963 if (!file_handle.opened_path) {
2964 file_handle.opened_path = estrdup(resolved_path);
2965 }
2966
2967 if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
2968 new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
2969 zend_destroy_file_handle(&file_handle TSRMLS_CC);
2970 } else {
2971 zend_file_handle_dtor(&file_handle TSRMLS_CC);
2972 failure_retval=1;
2973 }
2974 } else {
2975 if (opline->extended_value == ZEND_INCLUDE_ONCE) {
2976 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
2977 } else {
2978 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
2979 }
2980 }
2981 if (resolved_path != Z_STRVAL_P(inc_filename)) {
2982 efree(resolved_path);
2983 }
2984 }
2985 break;
2986 case ZEND_INCLUDE:
2987 case ZEND_REQUIRE:
2988 new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC);
2989 break;
2990 case ZEND_EVAL: {
2991 char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
2992
2993 new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
2994 efree(eval_desc);
2995 }
2996 break;
2997 EMPTY_SWITCH_DEFAULT_CASE()
2998 }
2999 }
3000 if (tmp_inc_filename) {
3001 zval_ptr_dtor(&tmp_inc_filename);
3002 }
3003
3004 if (UNEXPECTED(EG(exception) != NULL)) {
3005 HANDLE_EXCEPTION();
3006 } else if (EXPECTED(new_op_array != NULL)) {
3007 EX(original_return_value) = EG(return_value_ptr_ptr);
3008 EG(active_op_array) = new_op_array;
3009 if (RETURN_VALUE_USED(opline)) {
3010 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
3011 EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
3012 } else {
3013 EG(return_value_ptr_ptr) = NULL;
3014 }
3015
3016 EX(function_state).function = (zend_function *) new_op_array;
3017 EX(object) = NULL;
3018
3019 if (!EG(active_symbol_table)) {
3020 zend_rebuild_symbol_table(TSRMLS_C);
3021 }
3022
3023 if (EXPECTED(zend_execute_ex == execute_ex)) {
3024 ZEND_VM_ENTER();
3025 } else {
3026 zend_execute(new_op_array TSRMLS_CC);
3027 }
3028
3029 EX(function_state).function = (zend_function *) EX(op_array);
3030
3031 EG(opline_ptr) = &EX(opline);
3032 EG(active_op_array) = EX(op_array);
3033 EG(return_value_ptr_ptr) = EX(original_return_value);
3034 destroy_op_array(new_op_array TSRMLS_CC);
3035 efree(new_op_array);
3036 if (UNEXPECTED(EG(exception) != NULL)) {
3037 zend_throw_exception_internal(NULL TSRMLS_CC);
3038 HANDLE_EXCEPTION();
3039 }
3040
3041 } else if (RETURN_VALUE_USED(opline)) {
3042 zval *retval;
3043
3044 ALLOC_ZVAL(retval);
3045 ZVAL_BOOL(retval, failure_retval);
3046 INIT_PZVAL(retval);
3047 EX_T(opline->result.var).var.ptr = retval;
3048 }
3049 ZEND_VM_NEXT_OPCODE();
3050 }
3051
ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3052 static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3053 {
3054 USE_OPLINE
3055
3056 zval *array_ptr, **array_ptr_ptr;
3057 HashTable *fe_ht;
3058 zend_object_iterator *iter = NULL;
3059 zend_class_entry *ce = NULL;
3060 zend_bool is_empty = 0;
3061
3062 SAVE_OPLINE();
3063
3064 if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) &&
3065 (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
3066 array_ptr_ptr = NULL;
3067 if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
3068 MAKE_STD_ZVAL(array_ptr);
3069 ZVAL_NULL(array_ptr);
3070 } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
3071 if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
3072 zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
3073 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
3074 }
3075
3076 ce = Z_OBJCE_PP(array_ptr_ptr);
3077 if (!ce || ce->get_iterator == NULL) {
3078 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
3079 Z_ADDREF_PP(array_ptr_ptr);
3080 }
3081 array_ptr = *array_ptr_ptr;
3082 } else {
3083 if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
3084 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
3085 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
3086 Z_SET_ISREF_PP(array_ptr_ptr);
3087 }
3088 }
3089 array_ptr = *array_ptr_ptr;
3090 Z_ADDREF_P(array_ptr);
3091 }
3092 } else {
3093 array_ptr = opline->op1.zv;
3094 if (0) { /* IS_TMP_VAR */
3095 zval *tmp;
3096
3097 ALLOC_ZVAL(tmp);
3098 INIT_PZVAL_COPY(tmp, array_ptr);
3099 array_ptr = tmp;
3100 if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
3101 ce = Z_OBJCE_P(array_ptr);
3102 if (ce && ce->get_iterator) {
3103 Z_DELREF_P(array_ptr);
3104 }
3105 }
3106 } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
3107 ce = Z_OBJCE_P(array_ptr);
3108 if (!ce || !ce->get_iterator) {
3109 if (IS_CONST == IS_CV) {
3110 Z_ADDREF_P(array_ptr);
3111 }
3112 }
3113 } else if (IS_CONST == IS_CONST ||
3114 (IS_CONST == IS_CV &&
3115 !Z_ISREF_P(array_ptr) &&
3116 Z_REFCOUNT_P(array_ptr) > 1) ||
3117 (IS_CONST == IS_VAR &&
3118 !Z_ISREF_P(array_ptr) &&
3119 Z_REFCOUNT_P(array_ptr) > 2)) {
3120 zval *tmp;
3121
3122 if (IS_CONST == IS_VAR) {
3123 Z_DELREF_P(array_ptr);
3124 }
3125 ALLOC_ZVAL(tmp);
3126 INIT_PZVAL_COPY(tmp, array_ptr);
3127 zval_copy_ctor(tmp);
3128 array_ptr = tmp;
3129 } else if (IS_CONST == IS_CV) {
3130 Z_ADDREF_P(array_ptr);
3131 }
3132 }
3133
3134 if (ce && ce->get_iterator) {
3135 iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
3136
3137 if (IS_CONST == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
3138
3139 }
3140 if (iter && EXPECTED(EG(exception) == NULL)) {
3141 array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
3142 } else {
3143 if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
3144
3145 }
3146 if (!EG(exception)) {
3147 zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
3148 }
3149 zend_throw_exception_internal(NULL TSRMLS_CC);
3150 HANDLE_EXCEPTION();
3151 }
3152 }
3153
3154 EX_T(opline->result.var).fe.ptr = array_ptr;
3155
3156 if (iter) {
3157 iter->index = 0;
3158 if (iter->funcs->rewind) {
3159 iter->funcs->rewind(iter TSRMLS_CC);
3160 if (UNEXPECTED(EG(exception) != NULL)) {
3161 zval_ptr_dtor(&array_ptr);
3162 if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
3163
3164 }
3165 HANDLE_EXCEPTION();
3166 }
3167 }
3168 is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
3169 if (UNEXPECTED(EG(exception) != NULL)) {
3170 zval_ptr_dtor(&array_ptr);
3171 if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
3172
3173 }
3174 HANDLE_EXCEPTION();
3175 }
3176 iter->index = -1; /* will be set to 0 before using next handler */
3177 } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
3178 zend_hash_internal_pointer_reset(fe_ht);
3179 if (ce) {
3180 zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
3181 while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
3182 char *str_key;
3183 uint str_key_len;
3184 ulong int_key;
3185 zend_uchar key_type;
3186
3187 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
3188 if (key_type != HASH_KEY_NON_EXISTENT &&
3189 (key_type == HASH_KEY_IS_LONG ||
3190 zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
3191 break;
3192 }
3193 zend_hash_move_forward(fe_ht);
3194 }
3195 }
3196 is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
3197 zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
3198 } else {
3199 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
3200 is_empty = 1;
3201 }
3202
3203 if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
3204
3205 }
3206 if (is_empty) {
3207 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
3208 } else {
3209 CHECK_EXCEPTION();
3210 ZEND_VM_NEXT_OPCODE();
3211 }
3212 }
3213
ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3214 static int ZEND_FASTCALL ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3215 {
3216 #if 0 || (IS_CONST != IS_UNUSED)
3217 USE_OPLINE
3218
3219 SAVE_OPLINE();
3220 if (IS_CONST != IS_UNUSED) {
3221
3222 zval *ptr = opline->op1.zv;
3223
3224 if (Z_TYPE_P(ptr) == IS_LONG) {
3225 EG(exit_status) = Z_LVAL_P(ptr);
3226 } else {
3227 zend_print_variable(ptr);
3228 }
3229
3230 }
3231 #endif
3232 zend_bailout();
3233 ZEND_VM_NEXT_OPCODE(); /* Never reached */
3234 }
3235
ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3236 static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3237 {
3238 USE_OPLINE
3239
3240 zval *value;
3241
3242 SAVE_OPLINE();
3243 value = opline->op1.zv;
3244
3245 if (i_zend_is_true(value)) {
3246 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
3247 if (!0) {
3248 zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
3249 }
3250
3251 #if DEBUG_ZEND>=2
3252 printf("Conditional jmp to %d\n", opline->op2.opline_num);
3253 #endif
3254 ZEND_VM_JMP(opline->op2.jmp_addr);
3255 }
3256
3257 CHECK_EXCEPTION();
3258 ZEND_VM_NEXT_OPCODE();
3259 }
3260
ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3261 static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3262 {
3263 USE_OPLINE
3264
3265 zval *value, *ret;
3266
3267 SAVE_OPLINE();
3268 value = opline->op1.zv;
3269
3270 if (i_zend_is_true(value)) {
3271 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
3272 Z_ADDREF_P(value);
3273 EX_T(opline->result.var).var.ptr = value;
3274 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
3275 } else {
3276 ALLOC_ZVAL(ret);
3277 INIT_PZVAL_COPY(ret, value);
3278 EX_T(opline->result.var).var.ptr = ret;
3279 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
3280 if (!0) {
3281 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
3282 }
3283 }
3284
3285 #if DEBUG_ZEND>=2
3286 printf("Conditional jmp to %d\n", opline->op2.opline_num);
3287 #endif
3288 ZEND_VM_JMP(opline->op2.jmp_addr);
3289 }
3290
3291 CHECK_EXCEPTION();
3292 ZEND_VM_NEXT_OPCODE();
3293 }
3294
ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3295 static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3296 {
3297 USE_OPLINE
3298
3299 zval *value;
3300
3301 SAVE_OPLINE();
3302 value = opline->op1.zv;
3303
3304 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
3305 if (!0) {
3306 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
3307 }
3308
3309 CHECK_EXCEPTION();
3310 ZEND_VM_NEXT_OPCODE();
3311 }
3312
ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3313 static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3314 {
3315 USE_OPLINE
3316
3317 zval *value, *ret;
3318
3319 SAVE_OPLINE();
3320 value = opline->op1.zv;
3321
3322 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
3323 Z_ADDREF_P(value);
3324 EX_T(opline->result.var).var.ptr = value;
3325 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
3326 } else {
3327 ALLOC_ZVAL(ret);
3328 INIT_PZVAL_COPY(ret, value);
3329 EX_T(opline->result.var).var.ptr = ret;
3330 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
3331 if (!0) {
3332 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
3333 }
3334 }
3335
3336 CHECK_EXCEPTION();
3337 ZEND_VM_NEXT_OPCODE();
3338 }
3339
ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3340 static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3341 {
3342 USE_OPLINE
3343
3344
3345 SAVE_OPLINE();
3346 fast_add_function(&EX_T(opline->result.var).tmp_var,
3347 opline->op1.zv,
3348 opline->op2.zv TSRMLS_CC);
3349
3350
3351 CHECK_EXCEPTION();
3352 ZEND_VM_NEXT_OPCODE();
3353 }
3354
ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3355 static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3356 {
3357 USE_OPLINE
3358
3359
3360 SAVE_OPLINE();
3361 fast_sub_function(&EX_T(opline->result.var).tmp_var,
3362 opline->op1.zv,
3363 opline->op2.zv TSRMLS_CC);
3364
3365
3366 CHECK_EXCEPTION();
3367 ZEND_VM_NEXT_OPCODE();
3368 }
3369
ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3370 static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3371 {
3372 USE_OPLINE
3373
3374
3375 SAVE_OPLINE();
3376 fast_mul_function(&EX_T(opline->result.var).tmp_var,
3377 opline->op1.zv,
3378 opline->op2.zv TSRMLS_CC);
3379
3380
3381 CHECK_EXCEPTION();
3382 ZEND_VM_NEXT_OPCODE();
3383 }
3384
ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3385 static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3386 {
3387 USE_OPLINE
3388
3389
3390 SAVE_OPLINE();
3391 fast_div_function(&EX_T(opline->result.var).tmp_var,
3392 opline->op1.zv,
3393 opline->op2.zv TSRMLS_CC);
3394
3395
3396 CHECK_EXCEPTION();
3397 ZEND_VM_NEXT_OPCODE();
3398 }
3399
ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3400 static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3401 {
3402 USE_OPLINE
3403
3404
3405 SAVE_OPLINE();
3406 fast_mod_function(&EX_T(opline->result.var).tmp_var,
3407 opline->op1.zv,
3408 opline->op2.zv TSRMLS_CC);
3409
3410
3411 CHECK_EXCEPTION();
3412 ZEND_VM_NEXT_OPCODE();
3413 }
3414
ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3415 static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3416 {
3417 USE_OPLINE
3418
3419
3420 SAVE_OPLINE();
3421 shift_left_function(&EX_T(opline->result.var).tmp_var,
3422 opline->op1.zv,
3423 opline->op2.zv TSRMLS_CC);
3424
3425
3426 CHECK_EXCEPTION();
3427 ZEND_VM_NEXT_OPCODE();
3428 }
3429
ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3430 static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3431 {
3432 USE_OPLINE
3433
3434
3435 SAVE_OPLINE();
3436 shift_right_function(&EX_T(opline->result.var).tmp_var,
3437 opline->op1.zv,
3438 opline->op2.zv TSRMLS_CC);
3439
3440
3441 CHECK_EXCEPTION();
3442 ZEND_VM_NEXT_OPCODE();
3443 }
3444
ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3445 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3446 {
3447 USE_OPLINE
3448
3449
3450 SAVE_OPLINE();
3451 concat_function(&EX_T(opline->result.var).tmp_var,
3452 opline->op1.zv,
3453 opline->op2.zv TSRMLS_CC);
3454
3455
3456 CHECK_EXCEPTION();
3457 ZEND_VM_NEXT_OPCODE();
3458 }
3459
ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3460 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3461 {
3462 USE_OPLINE
3463
3464
3465 SAVE_OPLINE();
3466 is_identical_function(&EX_T(opline->result.var).tmp_var,
3467 opline->op1.zv,
3468 opline->op2.zv TSRMLS_CC);
3469
3470
3471 CHECK_EXCEPTION();
3472 ZEND_VM_NEXT_OPCODE();
3473 }
3474
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3475 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3476 {
3477 USE_OPLINE
3478
3479 zval *result = &EX_T(opline->result.var).tmp_var;
3480
3481 SAVE_OPLINE();
3482 is_identical_function(result,
3483 opline->op1.zv,
3484 opline->op2.zv TSRMLS_CC);
3485 Z_LVAL_P(result) = !Z_LVAL_P(result);
3486
3487
3488 CHECK_EXCEPTION();
3489 ZEND_VM_NEXT_OPCODE();
3490 }
3491
ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3492 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3493 {
3494 USE_OPLINE
3495
3496 zval *result = &EX_T(opline->result.var).tmp_var;
3497
3498 SAVE_OPLINE();
3499 ZVAL_BOOL(result, fast_equal_function(result,
3500 opline->op1.zv,
3501 opline->op2.zv TSRMLS_CC));
3502
3503
3504 CHECK_EXCEPTION();
3505 ZEND_VM_NEXT_OPCODE();
3506 }
3507
ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3508 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3509 {
3510 USE_OPLINE
3511
3512 zval *result = &EX_T(opline->result.var).tmp_var;
3513
3514 SAVE_OPLINE();
3515 ZVAL_BOOL(result, fast_not_equal_function(result,
3516 opline->op1.zv,
3517 opline->op2.zv TSRMLS_CC));
3518
3519
3520 CHECK_EXCEPTION();
3521 ZEND_VM_NEXT_OPCODE();
3522 }
3523
ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3524 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3525 {
3526 USE_OPLINE
3527
3528 zval *result = &EX_T(opline->result.var).tmp_var;
3529
3530 SAVE_OPLINE();
3531 ZVAL_BOOL(result, fast_is_smaller_function(result,
3532 opline->op1.zv,
3533 opline->op2.zv TSRMLS_CC));
3534
3535
3536 CHECK_EXCEPTION();
3537 ZEND_VM_NEXT_OPCODE();
3538 }
3539
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3540 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3541 {
3542 USE_OPLINE
3543
3544 zval *result = &EX_T(opline->result.var).tmp_var;
3545
3546 SAVE_OPLINE();
3547 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
3548 opline->op1.zv,
3549 opline->op2.zv TSRMLS_CC));
3550
3551
3552 CHECK_EXCEPTION();
3553 ZEND_VM_NEXT_OPCODE();
3554 }
3555
ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3556 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3557 {
3558 USE_OPLINE
3559
3560
3561 SAVE_OPLINE();
3562 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
3563 opline->op1.zv,
3564 opline->op2.zv TSRMLS_CC);
3565
3566
3567 CHECK_EXCEPTION();
3568 ZEND_VM_NEXT_OPCODE();
3569 }
3570
ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3571 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3572 {
3573 USE_OPLINE
3574
3575
3576 SAVE_OPLINE();
3577 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
3578 opline->op1.zv,
3579 opline->op2.zv TSRMLS_CC);
3580
3581
3582 CHECK_EXCEPTION();
3583 ZEND_VM_NEXT_OPCODE();
3584 }
3585
ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3586 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3587 {
3588 USE_OPLINE
3589
3590
3591 SAVE_OPLINE();
3592 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
3593 opline->op1.zv,
3594 opline->op2.zv TSRMLS_CC);
3595
3596
3597 CHECK_EXCEPTION();
3598 ZEND_VM_NEXT_OPCODE();
3599 }
3600
ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3601 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3602 {
3603 USE_OPLINE
3604
3605
3606 SAVE_OPLINE();
3607 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
3608 opline->op1.zv,
3609 opline->op2.zv TSRMLS_CC);
3610
3611
3612 CHECK_EXCEPTION();
3613 ZEND_VM_NEXT_OPCODE();
3614 }
3615
zend_fetch_var_address_helper_SPEC_CONST_CONST(int type,ZEND_OPCODE_HANDLER_ARGS)3616 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
3617 {
3618 USE_OPLINE
3619 zend_free_op free_op1;
3620 zval *varname;
3621 zval **retval;
3622 zval tmp_varname;
3623 HashTable *target_symbol_table;
3624 ulong hash_value;
3625
3626 SAVE_OPLINE();
3627 varname = opline->op1.zv;
3628
3629 if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
3630 ZVAL_COPY_VALUE(&tmp_varname, varname);
3631 zval_copy_ctor(&tmp_varname);
3632 Z_SET_REFCOUNT(tmp_varname, 1);
3633 Z_UNSET_ISREF(tmp_varname);
3634 convert_to_string(&tmp_varname);
3635 varname = &tmp_varname;
3636 }
3637
3638 if (IS_CONST != IS_UNUSED) {
3639 zend_class_entry *ce;
3640
3641 if (IS_CONST == IS_CONST) {
3642 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
3643 ce = CACHED_PTR(opline->op2.literal->cache_slot);
3644 } else {
3645 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
3646 if (UNEXPECTED(ce == NULL)) {
3647 if (IS_CONST != IS_CONST && varname == &tmp_varname) {
3648 zval_dtor(&tmp_varname);
3649 }
3650
3651 CHECK_EXCEPTION();
3652 ZEND_VM_NEXT_OPCODE();
3653 }
3654 CACHE_PTR(opline->op2.literal->cache_slot, ce);
3655 }
3656 } else {
3657 ce = EX_T(opline->op2.var).class_entry;
3658 }
3659 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
3660
3661 } else {
3662 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
3663 /*
3664 if (!target_symbol_table) {
3665 CHECK_EXCEPTION();
3666 ZEND_VM_NEXT_OPCODE();
3667 }
3668 */
3669 if (IS_CONST == IS_CONST) {
3670 hash_value = Z_HASH_P(varname);
3671 } else {
3672 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
3673 }
3674
3675 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
3676 switch (type) {
3677 case BP_VAR_R:
3678 case BP_VAR_UNSET:
3679 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
3680 /* break missing intentionally */
3681 case BP_VAR_IS:
3682 retval = &EG(uninitialized_zval_ptr);
3683 break;
3684 case BP_VAR_RW:
3685 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
3686 /* break missing intentionally */
3687 case BP_VAR_W:
3688 Z_ADDREF_P(&EG(uninitialized_zval));
3689 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
3690 break;
3691 EMPTY_SWITCH_DEFAULT_CASE()
3692 }
3693 }
3694 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
3695 case ZEND_FETCH_GLOBAL:
3696 if (IS_CONST != IS_TMP_VAR) {
3697
3698 }
3699 break;
3700 case ZEND_FETCH_LOCAL:
3701
3702 break;
3703 case ZEND_FETCH_STATIC:
3704 zval_update_constant(retval, 1 TSRMLS_CC);
3705 break;
3706 case ZEND_FETCH_GLOBAL_LOCK:
3707 if (IS_CONST == IS_VAR && !free_op1.var) {
3708 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
3709 }
3710 break;
3711 }
3712 }
3713
3714
3715 if (IS_CONST != IS_CONST && varname == &tmp_varname) {
3716 zval_dtor(&tmp_varname);
3717 }
3718 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
3719 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
3720 }
3721 PZVAL_LOCK(*retval);
3722 switch (type) {
3723 case BP_VAR_R:
3724 case BP_VAR_IS:
3725 EX_T(opline->result.var).var.ptr = *retval;
3726 break;
3727 case BP_VAR_UNSET: {
3728 zend_free_op free_res;
3729
3730 PZVAL_UNLOCK(*retval, &free_res);
3731 if (retval != &EG(uninitialized_zval_ptr)) {
3732 SEPARATE_ZVAL_IF_NOT_REF(retval);
3733 }
3734 PZVAL_LOCK(*retval);
3735 FREE_OP_VAR_PTR(free_res);
3736 }
3737 /* break missing intentionally */
3738 default:
3739 EX_T(opline->result.var).var.ptr_ptr = retval;
3740 break;
3741 }
3742 CHECK_EXCEPTION();
3743 ZEND_VM_NEXT_OPCODE();
3744 }
3745
ZEND_FETCH_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3746 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3747 {
3748 return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3749 }
3750
ZEND_FETCH_W_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3751 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3752 {
3753 return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3754 }
3755
ZEND_FETCH_RW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3756 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3757 {
3758 return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3759 }
3760
ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3761 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3762 {
3763 USE_OPLINE
3764
3765 return zend_fetch_var_address_helper_SPEC_CONST_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3766 }
3767
ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3768 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3769 {
3770 return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3771 }
3772
ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3773 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3774 {
3775 return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3776 }
3777
ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3778 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3779 {
3780 USE_OPLINE
3781
3782 zval *container;
3783
3784 SAVE_OPLINE();
3785 container = opline->op1.zv;
3786 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
3787
3788 if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
3789
3790 }
3791 CHECK_EXCEPTION();
3792 ZEND_VM_NEXT_OPCODE();
3793 }
3794
ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3795 static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3796 {
3797 USE_OPLINE
3798
3799 zval *container;
3800
3801 SAVE_OPLINE();
3802 container = opline->op1.zv;
3803
3804 if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
3805 PZVAL_LOCK(&EG(uninitialized_zval));
3806 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
3807 } else {
3808
3809 zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
3810
3811 PZVAL_LOCK(value);
3812 EX_T(opline->result.var).var.ptr = value;
3813
3814 }
3815 CHECK_EXCEPTION();
3816 ZEND_VM_NEXT_OPCODE();
3817 }
3818
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3819 static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3820 {
3821 USE_OPLINE
3822 zval *function_name;
3823 zend_class_entry *ce;
3824 call_slot *call = EX(call_slots) + opline->result.num;
3825
3826 SAVE_OPLINE();
3827
3828 if (IS_CONST == IS_CONST) {
3829 /* no function found. try a static method in class */
3830 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
3831 ce = CACHED_PTR(opline->op1.literal->cache_slot);
3832 } else {
3833 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
3834 if (UNEXPECTED(EG(exception) != NULL)) {
3835 HANDLE_EXCEPTION();
3836 }
3837 if (UNEXPECTED(ce == NULL)) {
3838 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
3839 }
3840 CACHE_PTR(opline->op1.literal->cache_slot, ce);
3841 }
3842 call->called_scope = ce;
3843 } else {
3844 ce = EX_T(opline->op1.var).class_entry;
3845
3846 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
3847 call->called_scope = EG(called_scope);
3848 } else {
3849 call->called_scope = ce;
3850 }
3851 }
3852
3853 if (IS_CONST == IS_CONST &&
3854 IS_CONST == IS_CONST &&
3855 CACHED_PTR(opline->op2.literal->cache_slot)) {
3856 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
3857 } else if (IS_CONST != IS_CONST &&
3858 IS_CONST == IS_CONST &&
3859 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
3860 /* do nothing */
3861 } else if (IS_CONST != IS_UNUSED) {
3862 char *function_name_strval = NULL;
3863 int function_name_strlen = 0;
3864
3865
3866 if (IS_CONST == IS_CONST) {
3867 function_name_strval = Z_STRVAL_P(opline->op2.zv);
3868 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
3869 } else {
3870 function_name = opline->op2.zv;
3871
3872 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
3873 if (UNEXPECTED(EG(exception) != NULL)) {
3874 HANDLE_EXCEPTION();
3875 }
3876 zend_error_noreturn(E_ERROR, "Function name must be a string");
3877 } else {
3878 function_name_strval = Z_STRVAL_P(function_name);
3879 function_name_strlen = Z_STRLEN_P(function_name);
3880 }
3881 }
3882
3883 if (function_name_strval) {
3884 if (ce->get_static_method) {
3885 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3886 } else {
3887 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
3888 }
3889 if (UNEXPECTED(call->fbc == NULL)) {
3890 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
3891 }
3892 if (IS_CONST == IS_CONST &&
3893 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
3894 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
3895 if (IS_CONST == IS_CONST) {
3896 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
3897 } else {
3898 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
3899 }
3900 }
3901 }
3902 if (IS_CONST != IS_CONST) {
3903
3904 }
3905 } else {
3906 if (UNEXPECTED(ce->constructor == NULL)) {
3907 zend_error_noreturn(E_ERROR, "Cannot call constructor");
3908 }
3909 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
3910 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
3911 }
3912 call->fbc = ce->constructor;
3913 }
3914
3915 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
3916 call->object = NULL;
3917 } else {
3918 if (EG(This) &&
3919 Z_OBJ_HT_P(EG(This))->get_class_entry &&
3920 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
3921 /* We are calling method of the other (incompatible) class,
3922 but passing $this. This is done for compatibility with php-4. */
3923 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3924 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
3925 } else {
3926 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
3927 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
3928 }
3929 }
3930 if ((call->object = EG(This))) {
3931 Z_ADDREF_P(call->object);
3932 call->called_scope = Z_OBJCE_P(call->object);
3933 }
3934 }
3935
3936 call->num_additional_args = 0;
3937 call->is_ctor_call = 0;
3938 EX(call) = call;
3939
3940 CHECK_EXCEPTION();
3941 ZEND_VM_NEXT_OPCODE();
3942 }
3943
ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3944 static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3945 {
3946 USE_OPLINE
3947
3948
3949 SAVE_OPLINE();
3950 is_equal_function(&EX_T(opline->result.var).tmp_var,
3951 opline->op1.zv,
3952 opline->op2.zv TSRMLS_CC);
3953
3954 CHECK_EXCEPTION();
3955 ZEND_VM_NEXT_OPCODE();
3956 }
3957
ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3958 static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3959 {
3960 USE_OPLINE
3961
3962 SAVE_OPLINE();
3963 if (IS_CONST == IS_UNUSED) {
3964 zend_constant *c;
3965 zval *retval;
3966
3967 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
3968 c = CACHED_PTR(opline->op2.literal->cache_slot);
3969 } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
3970 if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
3971 char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
3972 if(!actual) {
3973 actual = Z_STRVAL_P(opline->op2.zv);
3974 } else {
3975 actual++;
3976 }
3977 /* non-qualified constant - allow text substitution */
3978 zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
3979 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
3980 CHECK_EXCEPTION();
3981 ZEND_VM_NEXT_OPCODE();
3982 } else {
3983 zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
3984 }
3985 } else {
3986 CACHE_PTR(opline->op2.literal->cache_slot, c);
3987 }
3988 retval = &EX_T(opline->result.var).tmp_var;
3989 ZVAL_COPY_VALUE(retval, &c->value);
3990 zval_copy_ctor(retval);
3991 } else {
3992 /* class constant */
3993 zend_class_entry *ce;
3994 zval **value;
3995
3996 if (IS_CONST == IS_CONST) {
3997 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
3998 value = CACHED_PTR(opline->op2.literal->cache_slot);
3999 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
4000 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
4001 goto constant_fetch_end;
4002 } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
4003 ce = CACHED_PTR(opline->op1.literal->cache_slot);
4004 } else {
4005 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
4006 if (UNEXPECTED(EG(exception) != NULL)) {
4007 HANDLE_EXCEPTION();
4008 }
4009 if (UNEXPECTED(ce == NULL)) {
4010 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
4011 }
4012 CACHE_PTR(opline->op1.literal->cache_slot, ce);
4013 }
4014 } else {
4015 ce = EX_T(opline->op1.var).class_entry;
4016 if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
4017 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
4018 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
4019 goto constant_fetch_end;
4020 }
4021 }
4022
4023 if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) {
4024 if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
4025 zend_class_entry *old_scope = EG(scope);
4026
4027 EG(scope) = ce;
4028 zval_update_constant(value, 1 TSRMLS_CC);
4029 EG(scope) = old_scope;
4030 }
4031 if (IS_CONST == IS_CONST) {
4032 CACHE_PTR(opline->op2.literal->cache_slot, value);
4033 } else {
4034 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
4035 }
4036 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
4037 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
4038 } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
4039 /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
4040 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
4041 } else {
4042 zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
4043 }
4044 }
4045 constant_fetch_end:
4046 CHECK_EXCEPTION();
4047 ZEND_VM_NEXT_OPCODE();
4048 }
4049
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4050 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4051 {
4052 USE_OPLINE
4053
4054 zval *expr_ptr;
4055
4056 SAVE_OPLINE();
4057 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
4058 zval **expr_ptr_ptr = NULL;
4059
4060 if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
4061 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
4062 }
4063 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
4064 expr_ptr = *expr_ptr_ptr;
4065 Z_ADDREF_P(expr_ptr);
4066 } else {
4067 expr_ptr=opline->op1.zv;
4068 if (0) { /* temporary variable */
4069 zval *new_expr;
4070
4071 ALLOC_ZVAL(new_expr);
4072 INIT_PZVAL_COPY(new_expr, expr_ptr);
4073 expr_ptr = new_expr;
4074 } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
4075 zval *new_expr;
4076
4077 ALLOC_ZVAL(new_expr);
4078 INIT_PZVAL_COPY(new_expr, expr_ptr);
4079 expr_ptr = new_expr;
4080 zendi_zval_copy_ctor(*expr_ptr);
4081
4082 } else if (IS_CONST == IS_CV) {
4083 Z_ADDREF_P(expr_ptr);
4084 }
4085 }
4086
4087 if (IS_CONST != IS_UNUSED) {
4088
4089 zval *offset = opline->op2.zv;
4090 ulong hval;
4091
4092 switch (Z_TYPE_P(offset)) {
4093 case IS_DOUBLE:
4094 hval = zend_dval_to_lval(Z_DVAL_P(offset));
4095 goto num_index;
4096 case IS_LONG:
4097 case IS_BOOL:
4098 hval = Z_LVAL_P(offset);
4099 num_index:
4100 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
4101 break;
4102 case IS_STRING:
4103 if (IS_CONST == IS_CONST) {
4104 hval = Z_HASH_P(offset);
4105 } else {
4106 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
4107 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
4108 }
4109 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
4110 break;
4111 case IS_NULL:
4112 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
4113 break;
4114 default:
4115 zend_error(E_WARNING, "Illegal offset type");
4116 zval_ptr_dtor(&expr_ptr);
4117 /* do nothing */
4118 break;
4119 }
4120
4121 } else {
4122 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
4123 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
4124 zval_ptr_dtor(&expr_ptr);
4125 }
4126 }
4127 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
4128
4129 }
4130 CHECK_EXCEPTION();
4131 ZEND_VM_NEXT_OPCODE();
4132 }
4133
ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4134 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4135 {
4136 USE_OPLINE
4137
4138 array_init(&EX_T(opline->result.var).tmp_var);
4139 if (IS_CONST == IS_UNUSED) {
4140 ZEND_VM_NEXT_OPCODE();
4141 #if 0 || IS_CONST != IS_UNUSED
4142 } else {
4143 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4144 #endif
4145 }
4146 }
4147
ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4148 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4149 {
4150 USE_OPLINE
4151 zval tmp, *varname;
4152 HashTable *target_symbol_table;
4153
4154
4155 SAVE_OPLINE();
4156 if (IS_CONST == IS_CV &&
4157 IS_CONST == IS_UNUSED &&
4158 (opline->extended_value & ZEND_QUICK_SET)) {
4159 if (EG(active_symbol_table)) {
4160 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
4161
4162 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
4163 EX_CV(opline->op1.var) = NULL;
4164 } else if (EX_CV(opline->op1.var)) {
4165 zval_ptr_dtor(EX_CV(opline->op1.var));
4166 EX_CV(opline->op1.var) = NULL;
4167 }
4168 CHECK_EXCEPTION();
4169 ZEND_VM_NEXT_OPCODE();
4170 }
4171
4172 varname = opline->op1.zv;
4173
4174 if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
4175 ZVAL_COPY_VALUE(&tmp, varname);
4176 zval_copy_ctor(&tmp);
4177 convert_to_string(&tmp);
4178 varname = &tmp;
4179 } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
4180 Z_ADDREF_P(varname);
4181 }
4182
4183 if (IS_CONST != IS_UNUSED) {
4184 zend_class_entry *ce;
4185
4186 if (IS_CONST == IS_CONST) {
4187 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
4188 ce = CACHED_PTR(opline->op2.literal->cache_slot);
4189 } else {
4190 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
4191 if (UNEXPECTED(EG(exception) != NULL)) {
4192 if (IS_CONST != IS_CONST && varname == &tmp) {
4193 zval_dtor(&tmp);
4194 } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
4195 zval_ptr_dtor(&varname);
4196 }
4197
4198 HANDLE_EXCEPTION();
4199 }
4200 if (UNEXPECTED(ce == NULL)) {
4201 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
4202 }
4203 CACHE_PTR(opline->op2.literal->cache_slot, ce);
4204 }
4205 } else {
4206 ce = EX_T(opline->op2.var).class_entry;
4207 }
4208 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
4209 } else {
4210 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
4211
4212 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
4213 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
4214 }
4215
4216 if (IS_CONST != IS_CONST && varname == &tmp) {
4217 zval_dtor(&tmp);
4218 } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
4219 zval_ptr_dtor(&varname);
4220 }
4221
4222 CHECK_EXCEPTION();
4223 ZEND_VM_NEXT_OPCODE();
4224 }
4225
ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4226 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4227 {
4228 USE_OPLINE
4229 zval **value;
4230 zend_bool isset = 1;
4231
4232 SAVE_OPLINE();
4233 if (IS_CONST == IS_CV &&
4234 IS_CONST == IS_UNUSED &&
4235 (opline->extended_value & ZEND_QUICK_SET)) {
4236 if (EX_CV(opline->op1.var)) {
4237 value = EX_CV(opline->op1.var);
4238 } else if (EG(active_symbol_table)) {
4239 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
4240
4241 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
4242 isset = 0;
4243 }
4244 } else {
4245 isset = 0;
4246 }
4247 } else {
4248 HashTable *target_symbol_table;
4249
4250 zval tmp, *varname = opline->op1.zv;
4251
4252 if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
4253 ZVAL_COPY_VALUE(&tmp, varname);
4254 zval_copy_ctor(&tmp);
4255 convert_to_string(&tmp);
4256 varname = &tmp;
4257 }
4258
4259 if (IS_CONST != IS_UNUSED) {
4260 zend_class_entry *ce;
4261
4262 if (IS_CONST == IS_CONST) {
4263 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
4264 ce = CACHED_PTR(opline->op2.literal->cache_slot);
4265 } else {
4266 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
4267 if (UNEXPECTED(ce == NULL)) {
4268 CHECK_EXCEPTION();
4269 ZEND_VM_NEXT_OPCODE();
4270 }
4271 CACHE_PTR(opline->op2.literal->cache_slot, ce);
4272 }
4273 } else {
4274 ce = EX_T(opline->op2.var).class_entry;
4275 }
4276 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
4277 if (!value) {
4278 isset = 0;
4279 }
4280 } else {
4281 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
4282 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
4283 isset = 0;
4284 }
4285 }
4286
4287 if (IS_CONST != IS_CONST && varname == &tmp) {
4288 zval_dtor(&tmp);
4289 }
4290
4291 }
4292
4293 if (opline->extended_value & ZEND_ISSET) {
4294 if (isset && Z_TYPE_PP(value) != IS_NULL) {
4295 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
4296 } else {
4297 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
4298 }
4299 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
4300 if (!isset || !i_zend_is_true(*value)) {
4301 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
4302 } else {
4303 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
4304 }
4305 }
4306
4307 CHECK_EXCEPTION();
4308 ZEND_VM_NEXT_OPCODE();
4309 }
4310
ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4311 static int ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4312 {
4313 USE_OPLINE
4314
4315 zval *name;
4316 zval *val;
4317 zend_constant c;
4318
4319 SAVE_OPLINE();
4320 name = opline->op1.zv;
4321 val = opline->op2.zv;
4322
4323 if (IS_CONSTANT_TYPE(Z_TYPE_P(val))) {
4324 zval tmp;
4325 zval *tmp_ptr = &tmp;
4326
4327 ZVAL_COPY_VALUE(&tmp, val);
4328 INIT_PZVAL(&tmp);
4329 zval_update_constant(&tmp_ptr, 0 TSRMLS_CC);
4330 c.value = *tmp_ptr;
4331 } else {
4332 INIT_PZVAL_COPY(&c.value, val);
4333 if (Z_TYPE(c.value) == IS_ARRAY) {
4334 HashTable *ht;
4335
4336 ALLOC_HASHTABLE(ht);
4337 zend_hash_init(ht, zend_hash_num_elements(Z_ARRVAL(c.value)), NULL, ZVAL_PTR_DTOR, 0);
4338 zend_hash_copy(ht, Z_ARRVAL(c.value), (copy_ctor_func_t) zval_deep_copy, NULL, sizeof(zval *));
4339 Z_ARRVAL(c.value) = ht;
4340 } else {
4341 zval_copy_ctor(&c.value);
4342 }
4343 }
4344 c.flags = CONST_CS; /* non persistent, case sensetive */
4345 c.name = str_strndup(Z_STRVAL_P(name), Z_STRLEN_P(name));
4346 c.name_len = Z_STRLEN_P(name)+1;
4347 c.module_number = PHP_USER_CONSTANT;
4348
4349 if (zend_register_constant(&c TSRMLS_CC) == FAILURE) {
4350 }
4351
4352
4353 CHECK_EXCEPTION();
4354 ZEND_VM_NEXT_OPCODE();
4355 }
4356
ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4357 static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4358 {
4359 USE_OPLINE
4360
4361 /* The generator object is stored in return_value_ptr_ptr */
4362 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
4363
4364 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
4365 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
4366 }
4367
4368 /* Destroy the previously yielded value */
4369 if (generator->value) {
4370 zval_ptr_dtor(&generator->value);
4371 }
4372
4373 /* Destroy the previously yielded key */
4374 if (generator->key) {
4375 zval_ptr_dtor(&generator->key);
4376 }
4377
4378 /* Set the new yielded value */
4379 if (IS_CONST != IS_UNUSED) {
4380
4381
4382 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
4383 /* Constants and temporary variables aren't yieldable by reference,
4384 * but we still allow them with a notice. */
4385 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
4386 zval *value, *copy;
4387
4388 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
4389
4390 value = opline->op1.zv;
4391 ALLOC_ZVAL(copy);
4392 INIT_PZVAL_COPY(copy, value);
4393
4394 /* Temporary variables don't need ctor copying */
4395 if (!0) {
4396 zval_copy_ctor(copy);
4397 }
4398
4399 generator->value = copy;
4400 } else {
4401 zval **value_ptr = NULL;
4402
4403 if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
4404 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
4405 }
4406
4407 /* If a function call result is yielded and the function did
4408 * not return by reference we throw a notice. */
4409 if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
4410 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
4411 && EX_T(opline->op1.var).var.fcall_returned_reference)
4412 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
4413 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
4414
4415 Z_ADDREF_PP(value_ptr);
4416 generator->value = *value_ptr;
4417 } else {
4418 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
4419 Z_ADDREF_PP(value_ptr);
4420 generator->value = *value_ptr;
4421 }
4422
4423 }
4424 } else {
4425 zval *value = opline->op1.zv;
4426
4427 /* Consts, temporary variables and references need copying */
4428 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
4429 || PZVAL_IS_REF(value)
4430 ) {
4431 zval *copy;
4432
4433 ALLOC_ZVAL(copy);
4434 INIT_PZVAL_COPY(copy, value);
4435
4436 /* Temporary variables don't need ctor copying */
4437 if (!0) {
4438 zval_copy_ctor(copy);
4439 }
4440
4441 generator->value = copy;
4442
4443 } else {
4444 if (IS_CONST == IS_CV) {
4445 Z_ADDREF_P(value);
4446 }
4447 generator->value = value;
4448 }
4449 }
4450 } else {
4451 /* If no value was specified yield null */
4452 Z_ADDREF(EG(uninitialized_zval));
4453 generator->value = &EG(uninitialized_zval);
4454 }
4455
4456 /* Set the new yielded key */
4457 if (IS_CONST != IS_UNUSED) {
4458
4459 zval *key = opline->op2.zv;
4460
4461 /* Consts, temporary variables and references need copying */
4462 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
4463 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
4464 ) {
4465 zval *copy;
4466
4467 ALLOC_ZVAL(copy);
4468 INIT_PZVAL_COPY(copy, key);
4469
4470 /* Temporary variables don't need ctor copying */
4471 if (!0) {
4472 zval_copy_ctor(copy);
4473 }
4474
4475 generator->key = copy;
4476 } else {
4477 Z_ADDREF_P(key);
4478 generator->key = key;
4479 }
4480
4481 if (Z_TYPE_P(generator->key) == IS_LONG
4482 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
4483 ) {
4484 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
4485 }
4486
4487 } else {
4488 /* If no key was specified we use auto-increment keys */
4489 generator->largest_used_integer_key++;
4490
4491 ALLOC_INIT_ZVAL(generator->key);
4492 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
4493 }
4494
4495 if (RETURN_VALUE_USED(opline)) {
4496 /* If the return value of yield is used set the send
4497 * target and initialize it to NULL */
4498 generator->send_target = &EX_T(opline->result.var).var.ptr;
4499 Z_ADDREF(EG(uninitialized_zval));
4500 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
4501 } else {
4502 generator->send_target = NULL;
4503 }
4504
4505 /* We increment to the next op, so we are at the correct position when the
4506 * generator is resumed. */
4507 ZEND_VM_INC_OPCODE();
4508
4509 /* The GOTO VM uses a local opline variable. We need to set the opline
4510 * variable in execute_data so we don't resume at an old position. */
4511 SAVE_OPLINE();
4512
4513 ZEND_VM_RETURN();
4514 }
4515
ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4516 static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4517 {
4518 USE_OPLINE
4519
4520
4521 SAVE_OPLINE();
4522 pow_function(&EX_T(opline->result.var).tmp_var,
4523 opline->op1.zv,
4524 opline->op2.zv TSRMLS_CC);
4525
4526
4527 CHECK_EXCEPTION();
4528 ZEND_VM_NEXT_OPCODE();
4529 }
4530
ZEND_ADD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4531 static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4532 {
4533 USE_OPLINE
4534 zend_free_op free_op2;
4535
4536 SAVE_OPLINE();
4537 fast_add_function(&EX_T(opline->result.var).tmp_var,
4538 opline->op1.zv,
4539 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4540
4541 zval_dtor(free_op2.var);
4542 CHECK_EXCEPTION();
4543 ZEND_VM_NEXT_OPCODE();
4544 }
4545
ZEND_SUB_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4546 static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4547 {
4548 USE_OPLINE
4549 zend_free_op free_op2;
4550
4551 SAVE_OPLINE();
4552 fast_sub_function(&EX_T(opline->result.var).tmp_var,
4553 opline->op1.zv,
4554 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4555
4556 zval_dtor(free_op2.var);
4557 CHECK_EXCEPTION();
4558 ZEND_VM_NEXT_OPCODE();
4559 }
4560
ZEND_MUL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4561 static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4562 {
4563 USE_OPLINE
4564 zend_free_op free_op2;
4565
4566 SAVE_OPLINE();
4567 fast_mul_function(&EX_T(opline->result.var).tmp_var,
4568 opline->op1.zv,
4569 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4570
4571 zval_dtor(free_op2.var);
4572 CHECK_EXCEPTION();
4573 ZEND_VM_NEXT_OPCODE();
4574 }
4575
ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4576 static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4577 {
4578 USE_OPLINE
4579 zend_free_op free_op2;
4580
4581 SAVE_OPLINE();
4582 fast_div_function(&EX_T(opline->result.var).tmp_var,
4583 opline->op1.zv,
4584 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4585
4586 zval_dtor(free_op2.var);
4587 CHECK_EXCEPTION();
4588 ZEND_VM_NEXT_OPCODE();
4589 }
4590
ZEND_MOD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4591 static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4592 {
4593 USE_OPLINE
4594 zend_free_op free_op2;
4595
4596 SAVE_OPLINE();
4597 fast_mod_function(&EX_T(opline->result.var).tmp_var,
4598 opline->op1.zv,
4599 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4600
4601 zval_dtor(free_op2.var);
4602 CHECK_EXCEPTION();
4603 ZEND_VM_NEXT_OPCODE();
4604 }
4605
ZEND_SL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4606 static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4607 {
4608 USE_OPLINE
4609 zend_free_op free_op2;
4610
4611 SAVE_OPLINE();
4612 shift_left_function(&EX_T(opline->result.var).tmp_var,
4613 opline->op1.zv,
4614 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4615
4616 zval_dtor(free_op2.var);
4617 CHECK_EXCEPTION();
4618 ZEND_VM_NEXT_OPCODE();
4619 }
4620
ZEND_SR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4621 static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4622 {
4623 USE_OPLINE
4624 zend_free_op free_op2;
4625
4626 SAVE_OPLINE();
4627 shift_right_function(&EX_T(opline->result.var).tmp_var,
4628 opline->op1.zv,
4629 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4630
4631 zval_dtor(free_op2.var);
4632 CHECK_EXCEPTION();
4633 ZEND_VM_NEXT_OPCODE();
4634 }
4635
ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4636 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4637 {
4638 USE_OPLINE
4639 zend_free_op free_op2;
4640
4641 SAVE_OPLINE();
4642 concat_function(&EX_T(opline->result.var).tmp_var,
4643 opline->op1.zv,
4644 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4645
4646 zval_dtor(free_op2.var);
4647 CHECK_EXCEPTION();
4648 ZEND_VM_NEXT_OPCODE();
4649 }
4650
ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4651 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4652 {
4653 USE_OPLINE
4654 zend_free_op free_op2;
4655
4656 SAVE_OPLINE();
4657 is_identical_function(&EX_T(opline->result.var).tmp_var,
4658 opline->op1.zv,
4659 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4660
4661 zval_dtor(free_op2.var);
4662 CHECK_EXCEPTION();
4663 ZEND_VM_NEXT_OPCODE();
4664 }
4665
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4666 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4667 {
4668 USE_OPLINE
4669 zend_free_op free_op2;
4670 zval *result = &EX_T(opline->result.var).tmp_var;
4671
4672 SAVE_OPLINE();
4673 is_identical_function(result,
4674 opline->op1.zv,
4675 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4676 Z_LVAL_P(result) = !Z_LVAL_P(result);
4677
4678 zval_dtor(free_op2.var);
4679 CHECK_EXCEPTION();
4680 ZEND_VM_NEXT_OPCODE();
4681 }
4682
ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4683 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4684 {
4685 USE_OPLINE
4686 zend_free_op free_op2;
4687 zval *result = &EX_T(opline->result.var).tmp_var;
4688
4689 SAVE_OPLINE();
4690 ZVAL_BOOL(result, fast_equal_function(result,
4691 opline->op1.zv,
4692 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
4693
4694 zval_dtor(free_op2.var);
4695 CHECK_EXCEPTION();
4696 ZEND_VM_NEXT_OPCODE();
4697 }
4698
ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4699 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4700 {
4701 USE_OPLINE
4702 zend_free_op free_op2;
4703 zval *result = &EX_T(opline->result.var).tmp_var;
4704
4705 SAVE_OPLINE();
4706 ZVAL_BOOL(result, fast_not_equal_function(result,
4707 opline->op1.zv,
4708 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
4709
4710 zval_dtor(free_op2.var);
4711 CHECK_EXCEPTION();
4712 ZEND_VM_NEXT_OPCODE();
4713 }
4714
ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4715 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4716 {
4717 USE_OPLINE
4718 zend_free_op free_op2;
4719 zval *result = &EX_T(opline->result.var).tmp_var;
4720
4721 SAVE_OPLINE();
4722 ZVAL_BOOL(result, fast_is_smaller_function(result,
4723 opline->op1.zv,
4724 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
4725
4726 zval_dtor(free_op2.var);
4727 CHECK_EXCEPTION();
4728 ZEND_VM_NEXT_OPCODE();
4729 }
4730
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4731 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4732 {
4733 USE_OPLINE
4734 zend_free_op free_op2;
4735 zval *result = &EX_T(opline->result.var).tmp_var;
4736
4737 SAVE_OPLINE();
4738 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
4739 opline->op1.zv,
4740 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
4741
4742 zval_dtor(free_op2.var);
4743 CHECK_EXCEPTION();
4744 ZEND_VM_NEXT_OPCODE();
4745 }
4746
ZEND_BW_OR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4747 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4748 {
4749 USE_OPLINE
4750 zend_free_op free_op2;
4751
4752 SAVE_OPLINE();
4753 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
4754 opline->op1.zv,
4755 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4756
4757 zval_dtor(free_op2.var);
4758 CHECK_EXCEPTION();
4759 ZEND_VM_NEXT_OPCODE();
4760 }
4761
ZEND_BW_AND_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4762 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4763 {
4764 USE_OPLINE
4765 zend_free_op free_op2;
4766
4767 SAVE_OPLINE();
4768 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
4769 opline->op1.zv,
4770 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4771
4772 zval_dtor(free_op2.var);
4773 CHECK_EXCEPTION();
4774 ZEND_VM_NEXT_OPCODE();
4775 }
4776
ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4777 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4778 {
4779 USE_OPLINE
4780 zend_free_op free_op2;
4781
4782 SAVE_OPLINE();
4783 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
4784 opline->op1.zv,
4785 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4786
4787 zval_dtor(free_op2.var);
4788 CHECK_EXCEPTION();
4789 ZEND_VM_NEXT_OPCODE();
4790 }
4791
ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4792 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4793 {
4794 USE_OPLINE
4795 zend_free_op free_op2;
4796
4797 SAVE_OPLINE();
4798 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
4799 opline->op1.zv,
4800 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4801
4802 zval_dtor(free_op2.var);
4803 CHECK_EXCEPTION();
4804 ZEND_VM_NEXT_OPCODE();
4805 }
4806
ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4807 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4808 {
4809 USE_OPLINE
4810 zend_free_op free_op2;
4811 zval *container;
4812
4813 SAVE_OPLINE();
4814 container = opline->op1.zv;
4815 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
4816 zval_dtor(free_op2.var);
4817 if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
4818
4819 }
4820 CHECK_EXCEPTION();
4821 ZEND_VM_NEXT_OPCODE();
4822 }
4823
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4824 static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4825 {
4826 USE_OPLINE
4827 zval *function_name;
4828 zend_class_entry *ce;
4829 call_slot *call = EX(call_slots) + opline->result.num;
4830
4831 SAVE_OPLINE();
4832
4833 if (IS_CONST == IS_CONST) {
4834 /* no function found. try a static method in class */
4835 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
4836 ce = CACHED_PTR(opline->op1.literal->cache_slot);
4837 } else {
4838 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
4839 if (UNEXPECTED(EG(exception) != NULL)) {
4840 HANDLE_EXCEPTION();
4841 }
4842 if (UNEXPECTED(ce == NULL)) {
4843 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
4844 }
4845 CACHE_PTR(opline->op1.literal->cache_slot, ce);
4846 }
4847 call->called_scope = ce;
4848 } else {
4849 ce = EX_T(opline->op1.var).class_entry;
4850
4851 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
4852 call->called_scope = EG(called_scope);
4853 } else {
4854 call->called_scope = ce;
4855 }
4856 }
4857
4858 if (IS_CONST == IS_CONST &&
4859 IS_TMP_VAR == IS_CONST &&
4860 CACHED_PTR(opline->op2.literal->cache_slot)) {
4861 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
4862 } else if (IS_CONST != IS_CONST &&
4863 IS_TMP_VAR == IS_CONST &&
4864 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
4865 /* do nothing */
4866 } else if (IS_TMP_VAR != IS_UNUSED) {
4867 char *function_name_strval = NULL;
4868 int function_name_strlen = 0;
4869 zend_free_op free_op2;
4870
4871 if (IS_TMP_VAR == IS_CONST) {
4872 function_name_strval = Z_STRVAL_P(opline->op2.zv);
4873 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
4874 } else {
4875 function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
4876
4877 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
4878 if (UNEXPECTED(EG(exception) != NULL)) {
4879 HANDLE_EXCEPTION();
4880 }
4881 zend_error_noreturn(E_ERROR, "Function name must be a string");
4882 } else {
4883 function_name_strval = Z_STRVAL_P(function_name);
4884 function_name_strlen = Z_STRLEN_P(function_name);
4885 }
4886 }
4887
4888 if (function_name_strval) {
4889 if (ce->get_static_method) {
4890 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
4891 } else {
4892 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
4893 }
4894 if (UNEXPECTED(call->fbc == NULL)) {
4895 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
4896 }
4897 if (IS_TMP_VAR == IS_CONST &&
4898 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
4899 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
4900 if (IS_CONST == IS_CONST) {
4901 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
4902 } else {
4903 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
4904 }
4905 }
4906 }
4907 if (IS_TMP_VAR != IS_CONST) {
4908 zval_dtor(free_op2.var);
4909 }
4910 } else {
4911 if (UNEXPECTED(ce->constructor == NULL)) {
4912 zend_error_noreturn(E_ERROR, "Cannot call constructor");
4913 }
4914 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
4915 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
4916 }
4917 call->fbc = ce->constructor;
4918 }
4919
4920 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
4921 call->object = NULL;
4922 } else {
4923 if (EG(This) &&
4924 Z_OBJ_HT_P(EG(This))->get_class_entry &&
4925 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
4926 /* We are calling method of the other (incompatible) class,
4927 but passing $this. This is done for compatibility with php-4. */
4928 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
4929 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
4930 } else {
4931 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
4932 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
4933 }
4934 }
4935 if ((call->object = EG(This))) {
4936 Z_ADDREF_P(call->object);
4937 call->called_scope = Z_OBJCE_P(call->object);
4938 }
4939 }
4940
4941 call->num_additional_args = 0;
4942 call->is_ctor_call = 0;
4943 EX(call) = call;
4944
4945 CHECK_EXCEPTION();
4946 ZEND_VM_NEXT_OPCODE();
4947 }
4948
ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4949 static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4950 {
4951 USE_OPLINE
4952 zend_free_op free_op2;
4953
4954 SAVE_OPLINE();
4955 is_equal_function(&EX_T(opline->result.var).tmp_var,
4956 opline->op1.zv,
4957 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4958
4959 zval_dtor(free_op2.var);
4960 CHECK_EXCEPTION();
4961 ZEND_VM_NEXT_OPCODE();
4962 }
4963
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4964 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4965 {
4966 USE_OPLINE
4967
4968 zval *expr_ptr;
4969
4970 SAVE_OPLINE();
4971 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
4972 zval **expr_ptr_ptr = NULL;
4973
4974 if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
4975 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
4976 }
4977 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
4978 expr_ptr = *expr_ptr_ptr;
4979 Z_ADDREF_P(expr_ptr);
4980 } else {
4981 expr_ptr=opline->op1.zv;
4982 if (0) { /* temporary variable */
4983 zval *new_expr;
4984
4985 ALLOC_ZVAL(new_expr);
4986 INIT_PZVAL_COPY(new_expr, expr_ptr);
4987 expr_ptr = new_expr;
4988 } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
4989 zval *new_expr;
4990
4991 ALLOC_ZVAL(new_expr);
4992 INIT_PZVAL_COPY(new_expr, expr_ptr);
4993 expr_ptr = new_expr;
4994 zendi_zval_copy_ctor(*expr_ptr);
4995
4996 } else if (IS_CONST == IS_CV) {
4997 Z_ADDREF_P(expr_ptr);
4998 }
4999 }
5000
5001 if (IS_TMP_VAR != IS_UNUSED) {
5002 zend_free_op free_op2;
5003 zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
5004 ulong hval;
5005
5006 switch (Z_TYPE_P(offset)) {
5007 case IS_DOUBLE:
5008 hval = zend_dval_to_lval(Z_DVAL_P(offset));
5009 goto num_index;
5010 case IS_LONG:
5011 case IS_BOOL:
5012 hval = Z_LVAL_P(offset);
5013 num_index:
5014 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
5015 break;
5016 case IS_STRING:
5017 if (IS_TMP_VAR == IS_CONST) {
5018 hval = Z_HASH_P(offset);
5019 } else {
5020 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
5021 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
5022 }
5023 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
5024 break;
5025 case IS_NULL:
5026 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
5027 break;
5028 default:
5029 zend_error(E_WARNING, "Illegal offset type");
5030 zval_ptr_dtor(&expr_ptr);
5031 /* do nothing */
5032 break;
5033 }
5034 zval_dtor(free_op2.var);
5035 } else {
5036 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
5037 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
5038 zval_ptr_dtor(&expr_ptr);
5039 }
5040 }
5041 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
5042
5043 }
5044 CHECK_EXCEPTION();
5045 ZEND_VM_NEXT_OPCODE();
5046 }
5047
ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5048 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5049 {
5050 USE_OPLINE
5051
5052 array_init(&EX_T(opline->result.var).tmp_var);
5053 if (IS_CONST == IS_UNUSED) {
5054 ZEND_VM_NEXT_OPCODE();
5055 #if 0 || IS_CONST != IS_UNUSED
5056 } else {
5057 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5058 #endif
5059 }
5060 }
5061
ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5062 static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5063 {
5064 USE_OPLINE
5065
5066 /* The generator object is stored in return_value_ptr_ptr */
5067 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
5068
5069 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
5070 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
5071 }
5072
5073 /* Destroy the previously yielded value */
5074 if (generator->value) {
5075 zval_ptr_dtor(&generator->value);
5076 }
5077
5078 /* Destroy the previously yielded key */
5079 if (generator->key) {
5080 zval_ptr_dtor(&generator->key);
5081 }
5082
5083 /* Set the new yielded value */
5084 if (IS_CONST != IS_UNUSED) {
5085
5086
5087 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
5088 /* Constants and temporary variables aren't yieldable by reference,
5089 * but we still allow them with a notice. */
5090 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
5091 zval *value, *copy;
5092
5093 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
5094
5095 value = opline->op1.zv;
5096 ALLOC_ZVAL(copy);
5097 INIT_PZVAL_COPY(copy, value);
5098
5099 /* Temporary variables don't need ctor copying */
5100 if (!0) {
5101 zval_copy_ctor(copy);
5102 }
5103
5104 generator->value = copy;
5105 } else {
5106 zval **value_ptr = NULL;
5107
5108 if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
5109 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
5110 }
5111
5112 /* If a function call result is yielded and the function did
5113 * not return by reference we throw a notice. */
5114 if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
5115 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
5116 && EX_T(opline->op1.var).var.fcall_returned_reference)
5117 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
5118 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
5119
5120 Z_ADDREF_PP(value_ptr);
5121 generator->value = *value_ptr;
5122 } else {
5123 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
5124 Z_ADDREF_PP(value_ptr);
5125 generator->value = *value_ptr;
5126 }
5127
5128 }
5129 } else {
5130 zval *value = opline->op1.zv;
5131
5132 /* Consts, temporary variables and references need copying */
5133 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
5134 || PZVAL_IS_REF(value)
5135 ) {
5136 zval *copy;
5137
5138 ALLOC_ZVAL(copy);
5139 INIT_PZVAL_COPY(copy, value);
5140
5141 /* Temporary variables don't need ctor copying */
5142 if (!0) {
5143 zval_copy_ctor(copy);
5144 }
5145
5146 generator->value = copy;
5147
5148 } else {
5149 if (IS_CONST == IS_CV) {
5150 Z_ADDREF_P(value);
5151 }
5152 generator->value = value;
5153 }
5154 }
5155 } else {
5156 /* If no value was specified yield null */
5157 Z_ADDREF(EG(uninitialized_zval));
5158 generator->value = &EG(uninitialized_zval);
5159 }
5160
5161 /* Set the new yielded key */
5162 if (IS_TMP_VAR != IS_UNUSED) {
5163 zend_free_op free_op2;
5164 zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
5165
5166 /* Consts, temporary variables and references need copying */
5167 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
5168 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
5169 ) {
5170 zval *copy;
5171
5172 ALLOC_ZVAL(copy);
5173 INIT_PZVAL_COPY(copy, key);
5174
5175 /* Temporary variables don't need ctor copying */
5176 if (!1) {
5177 zval_copy_ctor(copy);
5178 }
5179
5180 generator->key = copy;
5181 } else {
5182 Z_ADDREF_P(key);
5183 generator->key = key;
5184 }
5185
5186 if (Z_TYPE_P(generator->key) == IS_LONG
5187 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
5188 ) {
5189 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
5190 }
5191
5192 } else {
5193 /* If no key was specified we use auto-increment keys */
5194 generator->largest_used_integer_key++;
5195
5196 ALLOC_INIT_ZVAL(generator->key);
5197 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
5198 }
5199
5200 if (RETURN_VALUE_USED(opline)) {
5201 /* If the return value of yield is used set the send
5202 * target and initialize it to NULL */
5203 generator->send_target = &EX_T(opline->result.var).var.ptr;
5204 Z_ADDREF(EG(uninitialized_zval));
5205 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
5206 } else {
5207 generator->send_target = NULL;
5208 }
5209
5210 /* We increment to the next op, so we are at the correct position when the
5211 * generator is resumed. */
5212 ZEND_VM_INC_OPCODE();
5213
5214 /* The GOTO VM uses a local opline variable. We need to set the opline
5215 * variable in execute_data so we don't resume at an old position. */
5216 SAVE_OPLINE();
5217
5218 ZEND_VM_RETURN();
5219 }
5220
ZEND_POW_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5221 static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5222 {
5223 USE_OPLINE
5224 zend_free_op free_op2;
5225
5226 SAVE_OPLINE();
5227 pow_function(&EX_T(opline->result.var).tmp_var,
5228 opline->op1.zv,
5229 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5230
5231 zval_dtor(free_op2.var);
5232 CHECK_EXCEPTION();
5233 ZEND_VM_NEXT_OPCODE();
5234 }
5235
ZEND_ADD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5236 static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5237 {
5238 USE_OPLINE
5239 zend_free_op free_op2;
5240
5241 SAVE_OPLINE();
5242 fast_add_function(&EX_T(opline->result.var).tmp_var,
5243 opline->op1.zv,
5244 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5245
5246 zval_ptr_dtor_nogc(&free_op2.var);
5247 CHECK_EXCEPTION();
5248 ZEND_VM_NEXT_OPCODE();
5249 }
5250
ZEND_SUB_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5251 static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5252 {
5253 USE_OPLINE
5254 zend_free_op free_op2;
5255
5256 SAVE_OPLINE();
5257 fast_sub_function(&EX_T(opline->result.var).tmp_var,
5258 opline->op1.zv,
5259 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5260
5261 zval_ptr_dtor_nogc(&free_op2.var);
5262 CHECK_EXCEPTION();
5263 ZEND_VM_NEXT_OPCODE();
5264 }
5265
ZEND_MUL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5266 static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5267 {
5268 USE_OPLINE
5269 zend_free_op free_op2;
5270
5271 SAVE_OPLINE();
5272 fast_mul_function(&EX_T(opline->result.var).tmp_var,
5273 opline->op1.zv,
5274 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5275
5276 zval_ptr_dtor_nogc(&free_op2.var);
5277 CHECK_EXCEPTION();
5278 ZEND_VM_NEXT_OPCODE();
5279 }
5280
ZEND_DIV_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5281 static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5282 {
5283 USE_OPLINE
5284 zend_free_op free_op2;
5285
5286 SAVE_OPLINE();
5287 fast_div_function(&EX_T(opline->result.var).tmp_var,
5288 opline->op1.zv,
5289 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5290
5291 zval_ptr_dtor_nogc(&free_op2.var);
5292 CHECK_EXCEPTION();
5293 ZEND_VM_NEXT_OPCODE();
5294 }
5295
ZEND_MOD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5296 static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5297 {
5298 USE_OPLINE
5299 zend_free_op free_op2;
5300
5301 SAVE_OPLINE();
5302 fast_mod_function(&EX_T(opline->result.var).tmp_var,
5303 opline->op1.zv,
5304 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5305
5306 zval_ptr_dtor_nogc(&free_op2.var);
5307 CHECK_EXCEPTION();
5308 ZEND_VM_NEXT_OPCODE();
5309 }
5310
ZEND_SL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5311 static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5312 {
5313 USE_OPLINE
5314 zend_free_op free_op2;
5315
5316 SAVE_OPLINE();
5317 shift_left_function(&EX_T(opline->result.var).tmp_var,
5318 opline->op1.zv,
5319 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5320
5321 zval_ptr_dtor_nogc(&free_op2.var);
5322 CHECK_EXCEPTION();
5323 ZEND_VM_NEXT_OPCODE();
5324 }
5325
ZEND_SR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5326 static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5327 {
5328 USE_OPLINE
5329 zend_free_op free_op2;
5330
5331 SAVE_OPLINE();
5332 shift_right_function(&EX_T(opline->result.var).tmp_var,
5333 opline->op1.zv,
5334 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5335
5336 zval_ptr_dtor_nogc(&free_op2.var);
5337 CHECK_EXCEPTION();
5338 ZEND_VM_NEXT_OPCODE();
5339 }
5340
ZEND_CONCAT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5341 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5342 {
5343 USE_OPLINE
5344 zend_free_op free_op2;
5345
5346 SAVE_OPLINE();
5347 concat_function(&EX_T(opline->result.var).tmp_var,
5348 opline->op1.zv,
5349 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5350
5351 zval_ptr_dtor_nogc(&free_op2.var);
5352 CHECK_EXCEPTION();
5353 ZEND_VM_NEXT_OPCODE();
5354 }
5355
ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5356 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5357 {
5358 USE_OPLINE
5359 zend_free_op free_op2;
5360
5361 SAVE_OPLINE();
5362 is_identical_function(&EX_T(opline->result.var).tmp_var,
5363 opline->op1.zv,
5364 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5365
5366 zval_ptr_dtor_nogc(&free_op2.var);
5367 CHECK_EXCEPTION();
5368 ZEND_VM_NEXT_OPCODE();
5369 }
5370
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5371 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5372 {
5373 USE_OPLINE
5374 zend_free_op free_op2;
5375 zval *result = &EX_T(opline->result.var).tmp_var;
5376
5377 SAVE_OPLINE();
5378 is_identical_function(result,
5379 opline->op1.zv,
5380 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5381 Z_LVAL_P(result) = !Z_LVAL_P(result);
5382
5383 zval_ptr_dtor_nogc(&free_op2.var);
5384 CHECK_EXCEPTION();
5385 ZEND_VM_NEXT_OPCODE();
5386 }
5387
ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5388 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5389 {
5390 USE_OPLINE
5391 zend_free_op free_op2;
5392 zval *result = &EX_T(opline->result.var).tmp_var;
5393
5394 SAVE_OPLINE();
5395 ZVAL_BOOL(result, fast_equal_function(result,
5396 opline->op1.zv,
5397 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
5398
5399 zval_ptr_dtor_nogc(&free_op2.var);
5400 CHECK_EXCEPTION();
5401 ZEND_VM_NEXT_OPCODE();
5402 }
5403
ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5404 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5405 {
5406 USE_OPLINE
5407 zend_free_op free_op2;
5408 zval *result = &EX_T(opline->result.var).tmp_var;
5409
5410 SAVE_OPLINE();
5411 ZVAL_BOOL(result, fast_not_equal_function(result,
5412 opline->op1.zv,
5413 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
5414
5415 zval_ptr_dtor_nogc(&free_op2.var);
5416 CHECK_EXCEPTION();
5417 ZEND_VM_NEXT_OPCODE();
5418 }
5419
ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5420 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5421 {
5422 USE_OPLINE
5423 zend_free_op free_op2;
5424 zval *result = &EX_T(opline->result.var).tmp_var;
5425
5426 SAVE_OPLINE();
5427 ZVAL_BOOL(result, fast_is_smaller_function(result,
5428 opline->op1.zv,
5429 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
5430
5431 zval_ptr_dtor_nogc(&free_op2.var);
5432 CHECK_EXCEPTION();
5433 ZEND_VM_NEXT_OPCODE();
5434 }
5435
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5436 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5437 {
5438 USE_OPLINE
5439 zend_free_op free_op2;
5440 zval *result = &EX_T(opline->result.var).tmp_var;
5441
5442 SAVE_OPLINE();
5443 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
5444 opline->op1.zv,
5445 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
5446
5447 zval_ptr_dtor_nogc(&free_op2.var);
5448 CHECK_EXCEPTION();
5449 ZEND_VM_NEXT_OPCODE();
5450 }
5451
ZEND_BW_OR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5452 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5453 {
5454 USE_OPLINE
5455 zend_free_op free_op2;
5456
5457 SAVE_OPLINE();
5458 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
5459 opline->op1.zv,
5460 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5461
5462 zval_ptr_dtor_nogc(&free_op2.var);
5463 CHECK_EXCEPTION();
5464 ZEND_VM_NEXT_OPCODE();
5465 }
5466
ZEND_BW_AND_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5467 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5468 {
5469 USE_OPLINE
5470 zend_free_op free_op2;
5471
5472 SAVE_OPLINE();
5473 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
5474 opline->op1.zv,
5475 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5476
5477 zval_ptr_dtor_nogc(&free_op2.var);
5478 CHECK_EXCEPTION();
5479 ZEND_VM_NEXT_OPCODE();
5480 }
5481
ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5482 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5483 {
5484 USE_OPLINE
5485 zend_free_op free_op2;
5486
5487 SAVE_OPLINE();
5488 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
5489 opline->op1.zv,
5490 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5491
5492 zval_ptr_dtor_nogc(&free_op2.var);
5493 CHECK_EXCEPTION();
5494 ZEND_VM_NEXT_OPCODE();
5495 }
5496
ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5497 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5498 {
5499 USE_OPLINE
5500 zend_free_op free_op2;
5501
5502 SAVE_OPLINE();
5503 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
5504 opline->op1.zv,
5505 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5506
5507 zval_ptr_dtor_nogc(&free_op2.var);
5508 CHECK_EXCEPTION();
5509 ZEND_VM_NEXT_OPCODE();
5510 }
5511
zend_fetch_var_address_helper_SPEC_CONST_VAR(int type,ZEND_OPCODE_HANDLER_ARGS)5512 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
5513 {
5514 USE_OPLINE
5515 zend_free_op free_op1;
5516 zval *varname;
5517 zval **retval;
5518 zval tmp_varname;
5519 HashTable *target_symbol_table;
5520 ulong hash_value;
5521
5522 SAVE_OPLINE();
5523 varname = opline->op1.zv;
5524
5525 if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
5526 ZVAL_COPY_VALUE(&tmp_varname, varname);
5527 zval_copy_ctor(&tmp_varname);
5528 Z_SET_REFCOUNT(tmp_varname, 1);
5529 Z_UNSET_ISREF(tmp_varname);
5530 convert_to_string(&tmp_varname);
5531 varname = &tmp_varname;
5532 }
5533
5534 if (IS_VAR != IS_UNUSED) {
5535 zend_class_entry *ce;
5536
5537 if (IS_VAR == IS_CONST) {
5538 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
5539 ce = CACHED_PTR(opline->op2.literal->cache_slot);
5540 } else {
5541 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
5542 if (UNEXPECTED(ce == NULL)) {
5543 if (IS_CONST != IS_CONST && varname == &tmp_varname) {
5544 zval_dtor(&tmp_varname);
5545 }
5546
5547 CHECK_EXCEPTION();
5548 ZEND_VM_NEXT_OPCODE();
5549 }
5550 CACHE_PTR(opline->op2.literal->cache_slot, ce);
5551 }
5552 } else {
5553 ce = EX_T(opline->op2.var).class_entry;
5554 }
5555 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
5556
5557 } else {
5558 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
5559 /*
5560 if (!target_symbol_table) {
5561 CHECK_EXCEPTION();
5562 ZEND_VM_NEXT_OPCODE();
5563 }
5564 */
5565 if (IS_CONST == IS_CONST) {
5566 hash_value = Z_HASH_P(varname);
5567 } else {
5568 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
5569 }
5570
5571 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
5572 switch (type) {
5573 case BP_VAR_R:
5574 case BP_VAR_UNSET:
5575 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
5576 /* break missing intentionally */
5577 case BP_VAR_IS:
5578 retval = &EG(uninitialized_zval_ptr);
5579 break;
5580 case BP_VAR_RW:
5581 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
5582 /* break missing intentionally */
5583 case BP_VAR_W:
5584 Z_ADDREF_P(&EG(uninitialized_zval));
5585 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
5586 break;
5587 EMPTY_SWITCH_DEFAULT_CASE()
5588 }
5589 }
5590 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
5591 case ZEND_FETCH_GLOBAL:
5592 if (IS_CONST != IS_TMP_VAR) {
5593
5594 }
5595 break;
5596 case ZEND_FETCH_LOCAL:
5597
5598 break;
5599 case ZEND_FETCH_STATIC:
5600 zval_update_constant(retval, 1 TSRMLS_CC);
5601 break;
5602 case ZEND_FETCH_GLOBAL_LOCK:
5603 if (IS_CONST == IS_VAR && !free_op1.var) {
5604 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
5605 }
5606 break;
5607 }
5608 }
5609
5610
5611 if (IS_CONST != IS_CONST && varname == &tmp_varname) {
5612 zval_dtor(&tmp_varname);
5613 }
5614 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
5615 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
5616 }
5617 PZVAL_LOCK(*retval);
5618 switch (type) {
5619 case BP_VAR_R:
5620 case BP_VAR_IS:
5621 EX_T(opline->result.var).var.ptr = *retval;
5622 break;
5623 case BP_VAR_UNSET: {
5624 zend_free_op free_res;
5625
5626 PZVAL_UNLOCK(*retval, &free_res);
5627 if (retval != &EG(uninitialized_zval_ptr)) {
5628 SEPARATE_ZVAL_IF_NOT_REF(retval);
5629 }
5630 PZVAL_LOCK(*retval);
5631 FREE_OP_VAR_PTR(free_res);
5632 }
5633 /* break missing intentionally */
5634 default:
5635 EX_T(opline->result.var).var.ptr_ptr = retval;
5636 break;
5637 }
5638 CHECK_EXCEPTION();
5639 ZEND_VM_NEXT_OPCODE();
5640 }
5641
ZEND_FETCH_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5642 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5643 {
5644 return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5645 }
5646
ZEND_FETCH_W_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5647 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5648 {
5649 return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5650 }
5651
ZEND_FETCH_RW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5652 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5653 {
5654 return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5655 }
5656
ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5657 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5658 {
5659 USE_OPLINE
5660
5661 return zend_fetch_var_address_helper_SPEC_CONST_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5662 }
5663
ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5664 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5665 {
5666 return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5667 }
5668
ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5669 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5670 {
5671 return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5672 }
5673
ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5674 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5675 {
5676 USE_OPLINE
5677 zend_free_op free_op2;
5678 zval *container;
5679
5680 SAVE_OPLINE();
5681 container = opline->op1.zv;
5682 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
5683 zval_ptr_dtor_nogc(&free_op2.var);
5684 if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
5685
5686 }
5687 CHECK_EXCEPTION();
5688 ZEND_VM_NEXT_OPCODE();
5689 }
5690
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5691 static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5692 {
5693 USE_OPLINE
5694 zval *function_name;
5695 zend_class_entry *ce;
5696 call_slot *call = EX(call_slots) + opline->result.num;
5697
5698 SAVE_OPLINE();
5699
5700 if (IS_CONST == IS_CONST) {
5701 /* no function found. try a static method in class */
5702 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
5703 ce = CACHED_PTR(opline->op1.literal->cache_slot);
5704 } else {
5705 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
5706 if (UNEXPECTED(EG(exception) != NULL)) {
5707 HANDLE_EXCEPTION();
5708 }
5709 if (UNEXPECTED(ce == NULL)) {
5710 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
5711 }
5712 CACHE_PTR(opline->op1.literal->cache_slot, ce);
5713 }
5714 call->called_scope = ce;
5715 } else {
5716 ce = EX_T(opline->op1.var).class_entry;
5717
5718 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
5719 call->called_scope = EG(called_scope);
5720 } else {
5721 call->called_scope = ce;
5722 }
5723 }
5724
5725 if (IS_CONST == IS_CONST &&
5726 IS_VAR == IS_CONST &&
5727 CACHED_PTR(opline->op2.literal->cache_slot)) {
5728 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
5729 } else if (IS_CONST != IS_CONST &&
5730 IS_VAR == IS_CONST &&
5731 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
5732 /* do nothing */
5733 } else if (IS_VAR != IS_UNUSED) {
5734 char *function_name_strval = NULL;
5735 int function_name_strlen = 0;
5736 zend_free_op free_op2;
5737
5738 if (IS_VAR == IS_CONST) {
5739 function_name_strval = Z_STRVAL_P(opline->op2.zv);
5740 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
5741 } else {
5742 function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
5743
5744 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
5745 if (UNEXPECTED(EG(exception) != NULL)) {
5746 HANDLE_EXCEPTION();
5747 }
5748 zend_error_noreturn(E_ERROR, "Function name must be a string");
5749 } else {
5750 function_name_strval = Z_STRVAL_P(function_name);
5751 function_name_strlen = Z_STRLEN_P(function_name);
5752 }
5753 }
5754
5755 if (function_name_strval) {
5756 if (ce->get_static_method) {
5757 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
5758 } else {
5759 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
5760 }
5761 if (UNEXPECTED(call->fbc == NULL)) {
5762 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
5763 }
5764 if (IS_VAR == IS_CONST &&
5765 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
5766 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
5767 if (IS_CONST == IS_CONST) {
5768 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
5769 } else {
5770 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
5771 }
5772 }
5773 }
5774 if (IS_VAR != IS_CONST) {
5775 zval_ptr_dtor_nogc(&free_op2.var);
5776 }
5777 } else {
5778 if (UNEXPECTED(ce->constructor == NULL)) {
5779 zend_error_noreturn(E_ERROR, "Cannot call constructor");
5780 }
5781 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
5782 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
5783 }
5784 call->fbc = ce->constructor;
5785 }
5786
5787 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
5788 call->object = NULL;
5789 } else {
5790 if (EG(This) &&
5791 Z_OBJ_HT_P(EG(This))->get_class_entry &&
5792 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
5793 /* We are calling method of the other (incompatible) class,
5794 but passing $this. This is done for compatibility with php-4. */
5795 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
5796 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
5797 } else {
5798 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
5799 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
5800 }
5801 }
5802 if ((call->object = EG(This))) {
5803 Z_ADDREF_P(call->object);
5804 call->called_scope = Z_OBJCE_P(call->object);
5805 }
5806 }
5807
5808 call->num_additional_args = 0;
5809 call->is_ctor_call = 0;
5810 EX(call) = call;
5811
5812 CHECK_EXCEPTION();
5813 ZEND_VM_NEXT_OPCODE();
5814 }
5815
ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5816 static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5817 {
5818 USE_OPLINE
5819 zend_free_op free_op2;
5820
5821 SAVE_OPLINE();
5822 is_equal_function(&EX_T(opline->result.var).tmp_var,
5823 opline->op1.zv,
5824 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5825
5826 zval_ptr_dtor_nogc(&free_op2.var);
5827 CHECK_EXCEPTION();
5828 ZEND_VM_NEXT_OPCODE();
5829 }
5830
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5831 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5832 {
5833 USE_OPLINE
5834
5835 zval *expr_ptr;
5836
5837 SAVE_OPLINE();
5838 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
5839 zval **expr_ptr_ptr = NULL;
5840
5841 if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
5842 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
5843 }
5844 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
5845 expr_ptr = *expr_ptr_ptr;
5846 Z_ADDREF_P(expr_ptr);
5847 } else {
5848 expr_ptr=opline->op1.zv;
5849 if (0) { /* temporary variable */
5850 zval *new_expr;
5851
5852 ALLOC_ZVAL(new_expr);
5853 INIT_PZVAL_COPY(new_expr, expr_ptr);
5854 expr_ptr = new_expr;
5855 } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
5856 zval *new_expr;
5857
5858 ALLOC_ZVAL(new_expr);
5859 INIT_PZVAL_COPY(new_expr, expr_ptr);
5860 expr_ptr = new_expr;
5861 zendi_zval_copy_ctor(*expr_ptr);
5862
5863 } else if (IS_CONST == IS_CV) {
5864 Z_ADDREF_P(expr_ptr);
5865 }
5866 }
5867
5868 if (IS_VAR != IS_UNUSED) {
5869 zend_free_op free_op2;
5870 zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
5871 ulong hval;
5872
5873 switch (Z_TYPE_P(offset)) {
5874 case IS_DOUBLE:
5875 hval = zend_dval_to_lval(Z_DVAL_P(offset));
5876 goto num_index;
5877 case IS_LONG:
5878 case IS_BOOL:
5879 hval = Z_LVAL_P(offset);
5880 num_index:
5881 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
5882 break;
5883 case IS_STRING:
5884 if (IS_VAR == IS_CONST) {
5885 hval = Z_HASH_P(offset);
5886 } else {
5887 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
5888 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
5889 }
5890 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
5891 break;
5892 case IS_NULL:
5893 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
5894 break;
5895 default:
5896 zend_error(E_WARNING, "Illegal offset type");
5897 zval_ptr_dtor(&expr_ptr);
5898 /* do nothing */
5899 break;
5900 }
5901 zval_ptr_dtor_nogc(&free_op2.var);
5902 } else {
5903 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
5904 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
5905 zval_ptr_dtor(&expr_ptr);
5906 }
5907 }
5908 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
5909
5910 }
5911 CHECK_EXCEPTION();
5912 ZEND_VM_NEXT_OPCODE();
5913 }
5914
ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5915 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5916 {
5917 USE_OPLINE
5918
5919 array_init(&EX_T(opline->result.var).tmp_var);
5920 if (IS_CONST == IS_UNUSED) {
5921 ZEND_VM_NEXT_OPCODE();
5922 #if 0 || IS_CONST != IS_UNUSED
5923 } else {
5924 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5925 #endif
5926 }
5927 }
5928
ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5929 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5930 {
5931 USE_OPLINE
5932 zval tmp, *varname;
5933 HashTable *target_symbol_table;
5934
5935
5936 SAVE_OPLINE();
5937 if (IS_CONST == IS_CV &&
5938 IS_VAR == IS_UNUSED &&
5939 (opline->extended_value & ZEND_QUICK_SET)) {
5940 if (EG(active_symbol_table)) {
5941 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
5942
5943 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
5944 EX_CV(opline->op1.var) = NULL;
5945 } else if (EX_CV(opline->op1.var)) {
5946 zval_ptr_dtor(EX_CV(opline->op1.var));
5947 EX_CV(opline->op1.var) = NULL;
5948 }
5949 CHECK_EXCEPTION();
5950 ZEND_VM_NEXT_OPCODE();
5951 }
5952
5953 varname = opline->op1.zv;
5954
5955 if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
5956 ZVAL_COPY_VALUE(&tmp, varname);
5957 zval_copy_ctor(&tmp);
5958 convert_to_string(&tmp);
5959 varname = &tmp;
5960 } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5961 Z_ADDREF_P(varname);
5962 }
5963
5964 if (IS_VAR != IS_UNUSED) {
5965 zend_class_entry *ce;
5966
5967 if (IS_VAR == IS_CONST) {
5968 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
5969 ce = CACHED_PTR(opline->op2.literal->cache_slot);
5970 } else {
5971 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
5972 if (UNEXPECTED(EG(exception) != NULL)) {
5973 if (IS_CONST != IS_CONST && varname == &tmp) {
5974 zval_dtor(&tmp);
5975 } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5976 zval_ptr_dtor(&varname);
5977 }
5978
5979 HANDLE_EXCEPTION();
5980 }
5981 if (UNEXPECTED(ce == NULL)) {
5982 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
5983 }
5984 CACHE_PTR(opline->op2.literal->cache_slot, ce);
5985 }
5986 } else {
5987 ce = EX_T(opline->op2.var).class_entry;
5988 }
5989 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
5990 } else {
5991 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
5992
5993 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
5994 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
5995 }
5996
5997 if (IS_CONST != IS_CONST && varname == &tmp) {
5998 zval_dtor(&tmp);
5999 } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
6000 zval_ptr_dtor(&varname);
6001 }
6002
6003 CHECK_EXCEPTION();
6004 ZEND_VM_NEXT_OPCODE();
6005 }
6006
ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6007 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6008 {
6009 USE_OPLINE
6010 zval **value;
6011 zend_bool isset = 1;
6012
6013 SAVE_OPLINE();
6014 if (IS_CONST == IS_CV &&
6015 IS_VAR == IS_UNUSED &&
6016 (opline->extended_value & ZEND_QUICK_SET)) {
6017 if (EX_CV(opline->op1.var)) {
6018 value = EX_CV(opline->op1.var);
6019 } else if (EG(active_symbol_table)) {
6020 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
6021
6022 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
6023 isset = 0;
6024 }
6025 } else {
6026 isset = 0;
6027 }
6028 } else {
6029 HashTable *target_symbol_table;
6030
6031 zval tmp, *varname = opline->op1.zv;
6032
6033 if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
6034 ZVAL_COPY_VALUE(&tmp, varname);
6035 zval_copy_ctor(&tmp);
6036 convert_to_string(&tmp);
6037 varname = &tmp;
6038 }
6039
6040 if (IS_VAR != IS_UNUSED) {
6041 zend_class_entry *ce;
6042
6043 if (IS_VAR == IS_CONST) {
6044 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
6045 ce = CACHED_PTR(opline->op2.literal->cache_slot);
6046 } else {
6047 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
6048 if (UNEXPECTED(ce == NULL)) {
6049 CHECK_EXCEPTION();
6050 ZEND_VM_NEXT_OPCODE();
6051 }
6052 CACHE_PTR(opline->op2.literal->cache_slot, ce);
6053 }
6054 } else {
6055 ce = EX_T(opline->op2.var).class_entry;
6056 }
6057 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
6058 if (!value) {
6059 isset = 0;
6060 }
6061 } else {
6062 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
6063 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
6064 isset = 0;
6065 }
6066 }
6067
6068 if (IS_CONST != IS_CONST && varname == &tmp) {
6069 zval_dtor(&tmp);
6070 }
6071
6072 }
6073
6074 if (opline->extended_value & ZEND_ISSET) {
6075 if (isset && Z_TYPE_PP(value) != IS_NULL) {
6076 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
6077 } else {
6078 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
6079 }
6080 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
6081 if (!isset || !i_zend_is_true(*value)) {
6082 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
6083 } else {
6084 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
6085 }
6086 }
6087
6088 CHECK_EXCEPTION();
6089 ZEND_VM_NEXT_OPCODE();
6090 }
6091
ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6092 static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6093 {
6094 USE_OPLINE
6095
6096 /* The generator object is stored in return_value_ptr_ptr */
6097 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
6098
6099 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
6100 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
6101 }
6102
6103 /* Destroy the previously yielded value */
6104 if (generator->value) {
6105 zval_ptr_dtor(&generator->value);
6106 }
6107
6108 /* Destroy the previously yielded key */
6109 if (generator->key) {
6110 zval_ptr_dtor(&generator->key);
6111 }
6112
6113 /* Set the new yielded value */
6114 if (IS_CONST != IS_UNUSED) {
6115
6116
6117 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
6118 /* Constants and temporary variables aren't yieldable by reference,
6119 * but we still allow them with a notice. */
6120 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
6121 zval *value, *copy;
6122
6123 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
6124
6125 value = opline->op1.zv;
6126 ALLOC_ZVAL(copy);
6127 INIT_PZVAL_COPY(copy, value);
6128
6129 /* Temporary variables don't need ctor copying */
6130 if (!0) {
6131 zval_copy_ctor(copy);
6132 }
6133
6134 generator->value = copy;
6135 } else {
6136 zval **value_ptr = NULL;
6137
6138 if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
6139 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
6140 }
6141
6142 /* If a function call result is yielded and the function did
6143 * not return by reference we throw a notice. */
6144 if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
6145 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
6146 && EX_T(opline->op1.var).var.fcall_returned_reference)
6147 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
6148 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
6149
6150 Z_ADDREF_PP(value_ptr);
6151 generator->value = *value_ptr;
6152 } else {
6153 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
6154 Z_ADDREF_PP(value_ptr);
6155 generator->value = *value_ptr;
6156 }
6157
6158 }
6159 } else {
6160 zval *value = opline->op1.zv;
6161
6162 /* Consts, temporary variables and references need copying */
6163 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
6164 || PZVAL_IS_REF(value)
6165 ) {
6166 zval *copy;
6167
6168 ALLOC_ZVAL(copy);
6169 INIT_PZVAL_COPY(copy, value);
6170
6171 /* Temporary variables don't need ctor copying */
6172 if (!0) {
6173 zval_copy_ctor(copy);
6174 }
6175
6176 generator->value = copy;
6177
6178 } else {
6179 if (IS_CONST == IS_CV) {
6180 Z_ADDREF_P(value);
6181 }
6182 generator->value = value;
6183 }
6184 }
6185 } else {
6186 /* If no value was specified yield null */
6187 Z_ADDREF(EG(uninitialized_zval));
6188 generator->value = &EG(uninitialized_zval);
6189 }
6190
6191 /* Set the new yielded key */
6192 if (IS_VAR != IS_UNUSED) {
6193 zend_free_op free_op2;
6194 zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
6195
6196 /* Consts, temporary variables and references need copying */
6197 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
6198 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
6199 ) {
6200 zval *copy;
6201
6202 ALLOC_ZVAL(copy);
6203 INIT_PZVAL_COPY(copy, key);
6204
6205 /* Temporary variables don't need ctor copying */
6206 if (!0) {
6207 zval_copy_ctor(copy);
6208 }
6209
6210 generator->key = copy;
6211 } else {
6212 Z_ADDREF_P(key);
6213 generator->key = key;
6214 }
6215
6216 if (Z_TYPE_P(generator->key) == IS_LONG
6217 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
6218 ) {
6219 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
6220 }
6221
6222 zval_ptr_dtor_nogc(&free_op2.var);
6223 } else {
6224 /* If no key was specified we use auto-increment keys */
6225 generator->largest_used_integer_key++;
6226
6227 ALLOC_INIT_ZVAL(generator->key);
6228 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
6229 }
6230
6231 if (RETURN_VALUE_USED(opline)) {
6232 /* If the return value of yield is used set the send
6233 * target and initialize it to NULL */
6234 generator->send_target = &EX_T(opline->result.var).var.ptr;
6235 Z_ADDREF(EG(uninitialized_zval));
6236 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
6237 } else {
6238 generator->send_target = NULL;
6239 }
6240
6241 /* We increment to the next op, so we are at the correct position when the
6242 * generator is resumed. */
6243 ZEND_VM_INC_OPCODE();
6244
6245 /* The GOTO VM uses a local opline variable. We need to set the opline
6246 * variable in execute_data so we don't resume at an old position. */
6247 SAVE_OPLINE();
6248
6249 ZEND_VM_RETURN();
6250 }
6251
ZEND_POW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6252 static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6253 {
6254 USE_OPLINE
6255 zend_free_op free_op2;
6256
6257 SAVE_OPLINE();
6258 pow_function(&EX_T(opline->result.var).tmp_var,
6259 opline->op1.zv,
6260 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
6261
6262 zval_ptr_dtor_nogc(&free_op2.var);
6263 CHECK_EXCEPTION();
6264 ZEND_VM_NEXT_OPCODE();
6265 }
6266
zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type,ZEND_OPCODE_HANDLER_ARGS)6267 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
6268 {
6269 USE_OPLINE
6270 zend_free_op free_op1;
6271 zval *varname;
6272 zval **retval;
6273 zval tmp_varname;
6274 HashTable *target_symbol_table;
6275 ulong hash_value;
6276
6277 SAVE_OPLINE();
6278 varname = opline->op1.zv;
6279
6280 if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
6281 ZVAL_COPY_VALUE(&tmp_varname, varname);
6282 zval_copy_ctor(&tmp_varname);
6283 Z_SET_REFCOUNT(tmp_varname, 1);
6284 Z_UNSET_ISREF(tmp_varname);
6285 convert_to_string(&tmp_varname);
6286 varname = &tmp_varname;
6287 }
6288
6289 if (IS_UNUSED != IS_UNUSED) {
6290 zend_class_entry *ce;
6291
6292 if (IS_UNUSED == IS_CONST) {
6293 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
6294 ce = CACHED_PTR(opline->op2.literal->cache_slot);
6295 } else {
6296 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
6297 if (UNEXPECTED(ce == NULL)) {
6298 if (IS_CONST != IS_CONST && varname == &tmp_varname) {
6299 zval_dtor(&tmp_varname);
6300 }
6301
6302 CHECK_EXCEPTION();
6303 ZEND_VM_NEXT_OPCODE();
6304 }
6305 CACHE_PTR(opline->op2.literal->cache_slot, ce);
6306 }
6307 } else {
6308 ce = EX_T(opline->op2.var).class_entry;
6309 }
6310 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
6311
6312 } else {
6313 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
6314 /*
6315 if (!target_symbol_table) {
6316 CHECK_EXCEPTION();
6317 ZEND_VM_NEXT_OPCODE();
6318 }
6319 */
6320 if (IS_CONST == IS_CONST) {
6321 hash_value = Z_HASH_P(varname);
6322 } else {
6323 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
6324 }
6325
6326 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
6327 switch (type) {
6328 case BP_VAR_R:
6329 case BP_VAR_UNSET:
6330 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
6331 /* break missing intentionally */
6332 case BP_VAR_IS:
6333 retval = &EG(uninitialized_zval_ptr);
6334 break;
6335 case BP_VAR_RW:
6336 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
6337 /* break missing intentionally */
6338 case BP_VAR_W:
6339 Z_ADDREF_P(&EG(uninitialized_zval));
6340 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
6341 break;
6342 EMPTY_SWITCH_DEFAULT_CASE()
6343 }
6344 }
6345 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
6346 case ZEND_FETCH_GLOBAL:
6347 if (IS_CONST != IS_TMP_VAR) {
6348
6349 }
6350 break;
6351 case ZEND_FETCH_LOCAL:
6352
6353 break;
6354 case ZEND_FETCH_STATIC:
6355 zval_update_constant(retval, 1 TSRMLS_CC);
6356 break;
6357 case ZEND_FETCH_GLOBAL_LOCK:
6358 if (IS_CONST == IS_VAR && !free_op1.var) {
6359 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
6360 }
6361 break;
6362 }
6363 }
6364
6365
6366 if (IS_CONST != IS_CONST && varname == &tmp_varname) {
6367 zval_dtor(&tmp_varname);
6368 }
6369 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
6370 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
6371 }
6372 PZVAL_LOCK(*retval);
6373 switch (type) {
6374 case BP_VAR_R:
6375 case BP_VAR_IS:
6376 EX_T(opline->result.var).var.ptr = *retval;
6377 break;
6378 case BP_VAR_UNSET: {
6379 zend_free_op free_res;
6380
6381 PZVAL_UNLOCK(*retval, &free_res);
6382 if (retval != &EG(uninitialized_zval_ptr)) {
6383 SEPARATE_ZVAL_IF_NOT_REF(retval);
6384 }
6385 PZVAL_LOCK(*retval);
6386 FREE_OP_VAR_PTR(free_res);
6387 }
6388 /* break missing intentionally */
6389 default:
6390 EX_T(opline->result.var).var.ptr_ptr = retval;
6391 break;
6392 }
6393 CHECK_EXCEPTION();
6394 ZEND_VM_NEXT_OPCODE();
6395 }
6396
ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6397 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6398 {
6399 return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6400 }
6401
ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6402 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6403 {
6404 return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6405 }
6406
ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6407 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6408 {
6409 return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6410 }
6411
ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6412 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6413 {
6414 USE_OPLINE
6415
6416 return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6417 }
6418
ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6419 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6420 {
6421 return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6422 }
6423
ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6424 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6425 {
6426 return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6427 }
6428
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6429 static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6430 {
6431 USE_OPLINE
6432 zval *function_name;
6433 zend_class_entry *ce;
6434 call_slot *call = EX(call_slots) + opline->result.num;
6435
6436 SAVE_OPLINE();
6437
6438 if (IS_CONST == IS_CONST) {
6439 /* no function found. try a static method in class */
6440 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
6441 ce = CACHED_PTR(opline->op1.literal->cache_slot);
6442 } else {
6443 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
6444 if (UNEXPECTED(EG(exception) != NULL)) {
6445 HANDLE_EXCEPTION();
6446 }
6447 if (UNEXPECTED(ce == NULL)) {
6448 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
6449 }
6450 CACHE_PTR(opline->op1.literal->cache_slot, ce);
6451 }
6452 call->called_scope = ce;
6453 } else {
6454 ce = EX_T(opline->op1.var).class_entry;
6455
6456 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
6457 call->called_scope = EG(called_scope);
6458 } else {
6459 call->called_scope = ce;
6460 }
6461 }
6462
6463 if (IS_CONST == IS_CONST &&
6464 IS_UNUSED == IS_CONST &&
6465 CACHED_PTR(opline->op2.literal->cache_slot)) {
6466 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
6467 } else if (IS_CONST != IS_CONST &&
6468 IS_UNUSED == IS_CONST &&
6469 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
6470 /* do nothing */
6471 } else if (IS_UNUSED != IS_UNUSED) {
6472 char *function_name_strval = NULL;
6473 int function_name_strlen = 0;
6474
6475
6476 if (IS_UNUSED == IS_CONST) {
6477 function_name_strval = Z_STRVAL_P(opline->op2.zv);
6478 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
6479 } else {
6480 function_name = NULL;
6481
6482 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
6483 if (UNEXPECTED(EG(exception) != NULL)) {
6484 HANDLE_EXCEPTION();
6485 }
6486 zend_error_noreturn(E_ERROR, "Function name must be a string");
6487 } else {
6488 function_name_strval = Z_STRVAL_P(function_name);
6489 function_name_strlen = Z_STRLEN_P(function_name);
6490 }
6491 }
6492
6493 if (function_name_strval) {
6494 if (ce->get_static_method) {
6495 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
6496 } else {
6497 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
6498 }
6499 if (UNEXPECTED(call->fbc == NULL)) {
6500 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
6501 }
6502 if (IS_UNUSED == IS_CONST &&
6503 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
6504 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
6505 if (IS_CONST == IS_CONST) {
6506 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
6507 } else {
6508 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
6509 }
6510 }
6511 }
6512 if (IS_UNUSED != IS_CONST) {
6513
6514 }
6515 } else {
6516 if (UNEXPECTED(ce->constructor == NULL)) {
6517 zend_error_noreturn(E_ERROR, "Cannot call constructor");
6518 }
6519 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
6520 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
6521 }
6522 call->fbc = ce->constructor;
6523 }
6524
6525 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
6526 call->object = NULL;
6527 } else {
6528 if (EG(This) &&
6529 Z_OBJ_HT_P(EG(This))->get_class_entry &&
6530 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
6531 /* We are calling method of the other (incompatible) class,
6532 but passing $this. This is done for compatibility with php-4. */
6533 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
6534 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
6535 } else {
6536 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
6537 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
6538 }
6539 }
6540 if ((call->object = EG(This))) {
6541 Z_ADDREF_P(call->object);
6542 call->called_scope = Z_OBJCE_P(call->object);
6543 }
6544 }
6545
6546 call->num_additional_args = 0;
6547 call->is_ctor_call = 0;
6548 EX(call) = call;
6549
6550 CHECK_EXCEPTION();
6551 ZEND_VM_NEXT_OPCODE();
6552 }
6553
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6554 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6555 {
6556 USE_OPLINE
6557
6558 zval *expr_ptr;
6559
6560 SAVE_OPLINE();
6561 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
6562 zval **expr_ptr_ptr = NULL;
6563
6564 if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
6565 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
6566 }
6567 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
6568 expr_ptr = *expr_ptr_ptr;
6569 Z_ADDREF_P(expr_ptr);
6570 } else {
6571 expr_ptr=opline->op1.zv;
6572 if (0) { /* temporary variable */
6573 zval *new_expr;
6574
6575 ALLOC_ZVAL(new_expr);
6576 INIT_PZVAL_COPY(new_expr, expr_ptr);
6577 expr_ptr = new_expr;
6578 } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
6579 zval *new_expr;
6580
6581 ALLOC_ZVAL(new_expr);
6582 INIT_PZVAL_COPY(new_expr, expr_ptr);
6583 expr_ptr = new_expr;
6584 zendi_zval_copy_ctor(*expr_ptr);
6585
6586 } else if (IS_CONST == IS_CV) {
6587 Z_ADDREF_P(expr_ptr);
6588 }
6589 }
6590
6591 if (IS_UNUSED != IS_UNUSED) {
6592
6593 zval *offset = NULL;
6594 ulong hval;
6595
6596 switch (Z_TYPE_P(offset)) {
6597 case IS_DOUBLE:
6598 hval = zend_dval_to_lval(Z_DVAL_P(offset));
6599 goto num_index;
6600 case IS_LONG:
6601 case IS_BOOL:
6602 hval = Z_LVAL_P(offset);
6603 num_index:
6604 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
6605 break;
6606 case IS_STRING:
6607 if (IS_UNUSED == IS_CONST) {
6608 hval = Z_HASH_P(offset);
6609 } else {
6610 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
6611 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
6612 }
6613 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
6614 break;
6615 case IS_NULL:
6616 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
6617 break;
6618 default:
6619 zend_error(E_WARNING, "Illegal offset type");
6620 zval_ptr_dtor(&expr_ptr);
6621 /* do nothing */
6622 break;
6623 }
6624
6625 } else {
6626 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
6627 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
6628 zval_ptr_dtor(&expr_ptr);
6629 }
6630 }
6631 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
6632
6633 }
6634 CHECK_EXCEPTION();
6635 ZEND_VM_NEXT_OPCODE();
6636 }
6637
ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6638 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6639 {
6640 USE_OPLINE
6641
6642 array_init(&EX_T(opline->result.var).tmp_var);
6643 if (IS_CONST == IS_UNUSED) {
6644 ZEND_VM_NEXT_OPCODE();
6645 #if 0 || IS_CONST != IS_UNUSED
6646 } else {
6647 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6648 #endif
6649 }
6650 }
6651
ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6652 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6653 {
6654 USE_OPLINE
6655 zval tmp, *varname;
6656 HashTable *target_symbol_table;
6657
6658
6659 SAVE_OPLINE();
6660 if (IS_CONST == IS_CV &&
6661 IS_UNUSED == IS_UNUSED &&
6662 (opline->extended_value & ZEND_QUICK_SET)) {
6663 if (EG(active_symbol_table)) {
6664 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
6665
6666 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
6667 EX_CV(opline->op1.var) = NULL;
6668 } else if (EX_CV(opline->op1.var)) {
6669 zval_ptr_dtor(EX_CV(opline->op1.var));
6670 EX_CV(opline->op1.var) = NULL;
6671 }
6672 CHECK_EXCEPTION();
6673 ZEND_VM_NEXT_OPCODE();
6674 }
6675
6676 varname = opline->op1.zv;
6677
6678 if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
6679 ZVAL_COPY_VALUE(&tmp, varname);
6680 zval_copy_ctor(&tmp);
6681 convert_to_string(&tmp);
6682 varname = &tmp;
6683 } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
6684 Z_ADDREF_P(varname);
6685 }
6686
6687 if (IS_UNUSED != IS_UNUSED) {
6688 zend_class_entry *ce;
6689
6690 if (IS_UNUSED == IS_CONST) {
6691 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
6692 ce = CACHED_PTR(opline->op2.literal->cache_slot);
6693 } else {
6694 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
6695 if (UNEXPECTED(EG(exception) != NULL)) {
6696 if (IS_CONST != IS_CONST && varname == &tmp) {
6697 zval_dtor(&tmp);
6698 } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
6699 zval_ptr_dtor(&varname);
6700 }
6701
6702 HANDLE_EXCEPTION();
6703 }
6704 if (UNEXPECTED(ce == NULL)) {
6705 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
6706 }
6707 CACHE_PTR(opline->op2.literal->cache_slot, ce);
6708 }
6709 } else {
6710 ce = EX_T(opline->op2.var).class_entry;
6711 }
6712 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
6713 } else {
6714 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
6715
6716 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
6717 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
6718 }
6719
6720 if (IS_CONST != IS_CONST && varname == &tmp) {
6721 zval_dtor(&tmp);
6722 } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
6723 zval_ptr_dtor(&varname);
6724 }
6725
6726 CHECK_EXCEPTION();
6727 ZEND_VM_NEXT_OPCODE();
6728 }
6729
ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6730 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6731 {
6732 USE_OPLINE
6733 zval **value;
6734 zend_bool isset = 1;
6735
6736 SAVE_OPLINE();
6737 if (IS_CONST == IS_CV &&
6738 IS_UNUSED == IS_UNUSED &&
6739 (opline->extended_value & ZEND_QUICK_SET)) {
6740 if (EX_CV(opline->op1.var)) {
6741 value = EX_CV(opline->op1.var);
6742 } else if (EG(active_symbol_table)) {
6743 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
6744
6745 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
6746 isset = 0;
6747 }
6748 } else {
6749 isset = 0;
6750 }
6751 } else {
6752 HashTable *target_symbol_table;
6753
6754 zval tmp, *varname = opline->op1.zv;
6755
6756 if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
6757 ZVAL_COPY_VALUE(&tmp, varname);
6758 zval_copy_ctor(&tmp);
6759 convert_to_string(&tmp);
6760 varname = &tmp;
6761 }
6762
6763 if (IS_UNUSED != IS_UNUSED) {
6764 zend_class_entry *ce;
6765
6766 if (IS_UNUSED == IS_CONST) {
6767 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
6768 ce = CACHED_PTR(opline->op2.literal->cache_slot);
6769 } else {
6770 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
6771 if (UNEXPECTED(ce == NULL)) {
6772 CHECK_EXCEPTION();
6773 ZEND_VM_NEXT_OPCODE();
6774 }
6775 CACHE_PTR(opline->op2.literal->cache_slot, ce);
6776 }
6777 } else {
6778 ce = EX_T(opline->op2.var).class_entry;
6779 }
6780 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
6781 if (!value) {
6782 isset = 0;
6783 }
6784 } else {
6785 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
6786 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
6787 isset = 0;
6788 }
6789 }
6790
6791 if (IS_CONST != IS_CONST && varname == &tmp) {
6792 zval_dtor(&tmp);
6793 }
6794
6795 }
6796
6797 if (opline->extended_value & ZEND_ISSET) {
6798 if (isset && Z_TYPE_PP(value) != IS_NULL) {
6799 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
6800 } else {
6801 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
6802 }
6803 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
6804 if (!isset || !i_zend_is_true(*value)) {
6805 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
6806 } else {
6807 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
6808 }
6809 }
6810
6811 CHECK_EXCEPTION();
6812 ZEND_VM_NEXT_OPCODE();
6813 }
6814
ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6815 static int ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6816 {
6817 USE_OPLINE
6818 zend_function *op_array;
6819
6820 SAVE_OPLINE();
6821
6822 if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void *) &op_array) == FAILURE) ||
6823 UNEXPECTED(op_array->type != ZEND_USER_FUNCTION)) {
6824 zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
6825 }
6826
6827 if (UNEXPECTED((op_array->common.fn_flags & ZEND_ACC_STATIC) ||
6828 (EX(prev_execute_data) &&
6829 EX(prev_execute_data)->function_state.function->common.fn_flags & ZEND_ACC_STATIC))) {
6830 zend_create_closure(&EX_T(opline->result.var).tmp_var, (zend_function *) op_array, EG(called_scope), NULL TSRMLS_CC);
6831 } else {
6832 zend_create_closure(&EX_T(opline->result.var).tmp_var, (zend_function *) op_array, EG(scope), EG(This) TSRMLS_CC);
6833 }
6834
6835 CHECK_EXCEPTION();
6836 ZEND_VM_NEXT_OPCODE();
6837 }
6838
ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6839 static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6840 {
6841 USE_OPLINE
6842
6843 /* The generator object is stored in return_value_ptr_ptr */
6844 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
6845
6846 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
6847 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
6848 }
6849
6850 /* Destroy the previously yielded value */
6851 if (generator->value) {
6852 zval_ptr_dtor(&generator->value);
6853 }
6854
6855 /* Destroy the previously yielded key */
6856 if (generator->key) {
6857 zval_ptr_dtor(&generator->key);
6858 }
6859
6860 /* Set the new yielded value */
6861 if (IS_CONST != IS_UNUSED) {
6862
6863
6864 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
6865 /* Constants and temporary variables aren't yieldable by reference,
6866 * but we still allow them with a notice. */
6867 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
6868 zval *value, *copy;
6869
6870 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
6871
6872 value = opline->op1.zv;
6873 ALLOC_ZVAL(copy);
6874 INIT_PZVAL_COPY(copy, value);
6875
6876 /* Temporary variables don't need ctor copying */
6877 if (!0) {
6878 zval_copy_ctor(copy);
6879 }
6880
6881 generator->value = copy;
6882 } else {
6883 zval **value_ptr = NULL;
6884
6885 if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
6886 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
6887 }
6888
6889 /* If a function call result is yielded and the function did
6890 * not return by reference we throw a notice. */
6891 if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
6892 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
6893 && EX_T(opline->op1.var).var.fcall_returned_reference)
6894 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
6895 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
6896
6897 Z_ADDREF_PP(value_ptr);
6898 generator->value = *value_ptr;
6899 } else {
6900 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
6901 Z_ADDREF_PP(value_ptr);
6902 generator->value = *value_ptr;
6903 }
6904
6905 }
6906 } else {
6907 zval *value = opline->op1.zv;
6908
6909 /* Consts, temporary variables and references need copying */
6910 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
6911 || PZVAL_IS_REF(value)
6912 ) {
6913 zval *copy;
6914
6915 ALLOC_ZVAL(copy);
6916 INIT_PZVAL_COPY(copy, value);
6917
6918 /* Temporary variables don't need ctor copying */
6919 if (!0) {
6920 zval_copy_ctor(copy);
6921 }
6922
6923 generator->value = copy;
6924
6925 } else {
6926 if (IS_CONST == IS_CV) {
6927 Z_ADDREF_P(value);
6928 }
6929 generator->value = value;
6930 }
6931 }
6932 } else {
6933 /* If no value was specified yield null */
6934 Z_ADDREF(EG(uninitialized_zval));
6935 generator->value = &EG(uninitialized_zval);
6936 }
6937
6938 /* Set the new yielded key */
6939 if (IS_UNUSED != IS_UNUSED) {
6940
6941 zval *key = NULL;
6942
6943 /* Consts, temporary variables and references need copying */
6944 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
6945 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
6946 ) {
6947 zval *copy;
6948
6949 ALLOC_ZVAL(copy);
6950 INIT_PZVAL_COPY(copy, key);
6951
6952 /* Temporary variables don't need ctor copying */
6953 if (!0) {
6954 zval_copy_ctor(copy);
6955 }
6956
6957 generator->key = copy;
6958 } else {
6959 Z_ADDREF_P(key);
6960 generator->key = key;
6961 }
6962
6963 if (Z_TYPE_P(generator->key) == IS_LONG
6964 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
6965 ) {
6966 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
6967 }
6968
6969 } else {
6970 /* If no key was specified we use auto-increment keys */
6971 generator->largest_used_integer_key++;
6972
6973 ALLOC_INIT_ZVAL(generator->key);
6974 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
6975 }
6976
6977 if (RETURN_VALUE_USED(opline)) {
6978 /* If the return value of yield is used set the send
6979 * target and initialize it to NULL */
6980 generator->send_target = &EX_T(opline->result.var).var.ptr;
6981 Z_ADDREF(EG(uninitialized_zval));
6982 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
6983 } else {
6984 generator->send_target = NULL;
6985 }
6986
6987 /* We increment to the next op, so we are at the correct position when the
6988 * generator is resumed. */
6989 ZEND_VM_INC_OPCODE();
6990
6991 /* The GOTO VM uses a local opline variable. We need to set the opline
6992 * variable in execute_data so we don't resume at an old position. */
6993 SAVE_OPLINE();
6994
6995 ZEND_VM_RETURN();
6996 }
6997
ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6998 static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6999 {
7000 USE_OPLINE
7001
7002
7003 SAVE_OPLINE();
7004 fast_add_function(&EX_T(opline->result.var).tmp_var,
7005 opline->op1.zv,
7006 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7007
7008
7009 CHECK_EXCEPTION();
7010 ZEND_VM_NEXT_OPCODE();
7011 }
7012
ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7013 static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7014 {
7015 USE_OPLINE
7016
7017
7018 SAVE_OPLINE();
7019 fast_sub_function(&EX_T(opline->result.var).tmp_var,
7020 opline->op1.zv,
7021 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7022
7023
7024 CHECK_EXCEPTION();
7025 ZEND_VM_NEXT_OPCODE();
7026 }
7027
ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7028 static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7029 {
7030 USE_OPLINE
7031
7032
7033 SAVE_OPLINE();
7034 fast_mul_function(&EX_T(opline->result.var).tmp_var,
7035 opline->op1.zv,
7036 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7037
7038
7039 CHECK_EXCEPTION();
7040 ZEND_VM_NEXT_OPCODE();
7041 }
7042
ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7043 static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7044 {
7045 USE_OPLINE
7046
7047
7048 SAVE_OPLINE();
7049 fast_div_function(&EX_T(opline->result.var).tmp_var,
7050 opline->op1.zv,
7051 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7052
7053
7054 CHECK_EXCEPTION();
7055 ZEND_VM_NEXT_OPCODE();
7056 }
7057
ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7058 static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7059 {
7060 USE_OPLINE
7061
7062
7063 SAVE_OPLINE();
7064 fast_mod_function(&EX_T(opline->result.var).tmp_var,
7065 opline->op1.zv,
7066 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7067
7068
7069 CHECK_EXCEPTION();
7070 ZEND_VM_NEXT_OPCODE();
7071 }
7072
ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7073 static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7074 {
7075 USE_OPLINE
7076
7077
7078 SAVE_OPLINE();
7079 shift_left_function(&EX_T(opline->result.var).tmp_var,
7080 opline->op1.zv,
7081 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7082
7083
7084 CHECK_EXCEPTION();
7085 ZEND_VM_NEXT_OPCODE();
7086 }
7087
ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7088 static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7089 {
7090 USE_OPLINE
7091
7092
7093 SAVE_OPLINE();
7094 shift_right_function(&EX_T(opline->result.var).tmp_var,
7095 opline->op1.zv,
7096 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7097
7098
7099 CHECK_EXCEPTION();
7100 ZEND_VM_NEXT_OPCODE();
7101 }
7102
ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7103 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7104 {
7105 USE_OPLINE
7106
7107
7108 SAVE_OPLINE();
7109 concat_function(&EX_T(opline->result.var).tmp_var,
7110 opline->op1.zv,
7111 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7112
7113
7114 CHECK_EXCEPTION();
7115 ZEND_VM_NEXT_OPCODE();
7116 }
7117
ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7118 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7119 {
7120 USE_OPLINE
7121
7122
7123 SAVE_OPLINE();
7124 is_identical_function(&EX_T(opline->result.var).tmp_var,
7125 opline->op1.zv,
7126 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7127
7128
7129 CHECK_EXCEPTION();
7130 ZEND_VM_NEXT_OPCODE();
7131 }
7132
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7133 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7134 {
7135 USE_OPLINE
7136
7137 zval *result = &EX_T(opline->result.var).tmp_var;
7138
7139 SAVE_OPLINE();
7140 is_identical_function(result,
7141 opline->op1.zv,
7142 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7143 Z_LVAL_P(result) = !Z_LVAL_P(result);
7144
7145
7146 CHECK_EXCEPTION();
7147 ZEND_VM_NEXT_OPCODE();
7148 }
7149
ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7150 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7151 {
7152 USE_OPLINE
7153
7154 zval *result = &EX_T(opline->result.var).tmp_var;
7155
7156 SAVE_OPLINE();
7157 ZVAL_BOOL(result, fast_equal_function(result,
7158 opline->op1.zv,
7159 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
7160
7161
7162 CHECK_EXCEPTION();
7163 ZEND_VM_NEXT_OPCODE();
7164 }
7165
ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7166 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7167 {
7168 USE_OPLINE
7169
7170 zval *result = &EX_T(opline->result.var).tmp_var;
7171
7172 SAVE_OPLINE();
7173 ZVAL_BOOL(result, fast_not_equal_function(result,
7174 opline->op1.zv,
7175 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
7176
7177
7178 CHECK_EXCEPTION();
7179 ZEND_VM_NEXT_OPCODE();
7180 }
7181
ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7182 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7183 {
7184 USE_OPLINE
7185
7186 zval *result = &EX_T(opline->result.var).tmp_var;
7187
7188 SAVE_OPLINE();
7189 ZVAL_BOOL(result, fast_is_smaller_function(result,
7190 opline->op1.zv,
7191 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
7192
7193
7194 CHECK_EXCEPTION();
7195 ZEND_VM_NEXT_OPCODE();
7196 }
7197
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7198 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7199 {
7200 USE_OPLINE
7201
7202 zval *result = &EX_T(opline->result.var).tmp_var;
7203
7204 SAVE_OPLINE();
7205 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
7206 opline->op1.zv,
7207 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
7208
7209
7210 CHECK_EXCEPTION();
7211 ZEND_VM_NEXT_OPCODE();
7212 }
7213
ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7214 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7215 {
7216 USE_OPLINE
7217
7218
7219 SAVE_OPLINE();
7220 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
7221 opline->op1.zv,
7222 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7223
7224
7225 CHECK_EXCEPTION();
7226 ZEND_VM_NEXT_OPCODE();
7227 }
7228
ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7229 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7230 {
7231 USE_OPLINE
7232
7233
7234 SAVE_OPLINE();
7235 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
7236 opline->op1.zv,
7237 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7238
7239
7240 CHECK_EXCEPTION();
7241 ZEND_VM_NEXT_OPCODE();
7242 }
7243
ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7244 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7245 {
7246 USE_OPLINE
7247
7248
7249 SAVE_OPLINE();
7250 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
7251 opline->op1.zv,
7252 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7253
7254
7255 CHECK_EXCEPTION();
7256 ZEND_VM_NEXT_OPCODE();
7257 }
7258
ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7259 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7260 {
7261 USE_OPLINE
7262
7263
7264 SAVE_OPLINE();
7265 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
7266 opline->op1.zv,
7267 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7268
7269
7270 CHECK_EXCEPTION();
7271 ZEND_VM_NEXT_OPCODE();
7272 }
7273
ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7274 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7275 {
7276 USE_OPLINE
7277
7278 zval *container;
7279
7280 SAVE_OPLINE();
7281 container = opline->op1.zv;
7282 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
7283
7284 if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
7285
7286 }
7287 CHECK_EXCEPTION();
7288 ZEND_VM_NEXT_OPCODE();
7289 }
7290
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7291 static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7292 {
7293 USE_OPLINE
7294 zval *function_name;
7295 zend_class_entry *ce;
7296 call_slot *call = EX(call_slots) + opline->result.num;
7297
7298 SAVE_OPLINE();
7299
7300 if (IS_CONST == IS_CONST) {
7301 /* no function found. try a static method in class */
7302 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
7303 ce = CACHED_PTR(opline->op1.literal->cache_slot);
7304 } else {
7305 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
7306 if (UNEXPECTED(EG(exception) != NULL)) {
7307 HANDLE_EXCEPTION();
7308 }
7309 if (UNEXPECTED(ce == NULL)) {
7310 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
7311 }
7312 CACHE_PTR(opline->op1.literal->cache_slot, ce);
7313 }
7314 call->called_scope = ce;
7315 } else {
7316 ce = EX_T(opline->op1.var).class_entry;
7317
7318 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
7319 call->called_scope = EG(called_scope);
7320 } else {
7321 call->called_scope = ce;
7322 }
7323 }
7324
7325 if (IS_CONST == IS_CONST &&
7326 IS_CV == IS_CONST &&
7327 CACHED_PTR(opline->op2.literal->cache_slot)) {
7328 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
7329 } else if (IS_CONST != IS_CONST &&
7330 IS_CV == IS_CONST &&
7331 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
7332 /* do nothing */
7333 } else if (IS_CV != IS_UNUSED) {
7334 char *function_name_strval = NULL;
7335 int function_name_strlen = 0;
7336
7337
7338 if (IS_CV == IS_CONST) {
7339 function_name_strval = Z_STRVAL_P(opline->op2.zv);
7340 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
7341 } else {
7342 function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
7343
7344 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
7345 if (UNEXPECTED(EG(exception) != NULL)) {
7346 HANDLE_EXCEPTION();
7347 }
7348 zend_error_noreturn(E_ERROR, "Function name must be a string");
7349 } else {
7350 function_name_strval = Z_STRVAL_P(function_name);
7351 function_name_strlen = Z_STRLEN_P(function_name);
7352 }
7353 }
7354
7355 if (function_name_strval) {
7356 if (ce->get_static_method) {
7357 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
7358 } else {
7359 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
7360 }
7361 if (UNEXPECTED(call->fbc == NULL)) {
7362 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
7363 }
7364 if (IS_CV == IS_CONST &&
7365 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
7366 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
7367 if (IS_CONST == IS_CONST) {
7368 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
7369 } else {
7370 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
7371 }
7372 }
7373 }
7374 if (IS_CV != IS_CONST) {
7375
7376 }
7377 } else {
7378 if (UNEXPECTED(ce->constructor == NULL)) {
7379 zend_error_noreturn(E_ERROR, "Cannot call constructor");
7380 }
7381 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
7382 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
7383 }
7384 call->fbc = ce->constructor;
7385 }
7386
7387 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
7388 call->object = NULL;
7389 } else {
7390 if (EG(This) &&
7391 Z_OBJ_HT_P(EG(This))->get_class_entry &&
7392 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
7393 /* We are calling method of the other (incompatible) class,
7394 but passing $this. This is done for compatibility with php-4. */
7395 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
7396 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
7397 } else {
7398 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
7399 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
7400 }
7401 }
7402 if ((call->object = EG(This))) {
7403 Z_ADDREF_P(call->object);
7404 call->called_scope = Z_OBJCE_P(call->object);
7405 }
7406 }
7407
7408 call->num_additional_args = 0;
7409 call->is_ctor_call = 0;
7410 EX(call) = call;
7411
7412 CHECK_EXCEPTION();
7413 ZEND_VM_NEXT_OPCODE();
7414 }
7415
ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7416 static int ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7417 {
7418 USE_OPLINE
7419 zend_class_entry *ce, *catch_ce;
7420 zval *exception;
7421
7422 SAVE_OPLINE();
7423 /* Check whether an exception has been thrown, if not, jump over code */
7424 zend_exception_restore(TSRMLS_C);
7425 if (EG(exception) == NULL) {
7426 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
7427 ZEND_VM_CONTINUE(); /* CHECK_ME */
7428 }
7429 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
7430 catch_ce = CACHED_PTR(opline->op1.literal->cache_slot);
7431 } else {
7432 catch_ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC);
7433
7434 CACHE_PTR(opline->op1.literal->cache_slot, catch_ce);
7435 }
7436 ce = Z_OBJCE_P(EG(exception));
7437
7438 #ifdef HAVE_DTRACE
7439 if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
7440 DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
7441 }
7442 #endif /* HAVE_DTRACE */
7443
7444 if (ce != catch_ce) {
7445 if (!instanceof_function(ce, catch_ce TSRMLS_CC)) {
7446 if (opline->result.num) {
7447 zend_throw_exception_internal(NULL TSRMLS_CC);
7448 HANDLE_EXCEPTION();
7449 }
7450 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
7451 ZEND_VM_CONTINUE(); /* CHECK_ME */
7452 }
7453 }
7454
7455 exception = EG(exception);
7456 if (!EG(active_symbol_table)) {
7457 if (EX_CV(opline->op2.var)) {
7458 zval_ptr_dtor(EX_CV(opline->op2.var));
7459 }
7460 EX_CV(opline->op2.var) = (zval**)EX_CV_NUM(execute_data, EX(op_array)->last_var + opline->op2.var);
7461 *EX_CV(opline->op2.var) = EG(exception);
7462 } else {
7463 zend_compiled_variable *cv = &CV_DEF_OF(opline->op2.var);
7464 zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value,
7465 &EG(exception), sizeof(zval *), (void**)&EX_CV(opline->op2.var));
7466 }
7467 if (UNEXPECTED(EG(exception) != exception)) {
7468 Z_ADDREF_P(EG(exception));
7469 HANDLE_EXCEPTION();
7470 } else {
7471 EG(exception) = NULL;
7472 ZEND_VM_NEXT_OPCODE();
7473 }
7474 }
7475
ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7476 static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7477 {
7478 USE_OPLINE
7479
7480
7481 SAVE_OPLINE();
7482 is_equal_function(&EX_T(opline->result.var).tmp_var,
7483 opline->op1.zv,
7484 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7485
7486 CHECK_EXCEPTION();
7487 ZEND_VM_NEXT_OPCODE();
7488 }
7489
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7490 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7491 {
7492 USE_OPLINE
7493
7494 zval *expr_ptr;
7495
7496 SAVE_OPLINE();
7497 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
7498 zval **expr_ptr_ptr = NULL;
7499
7500 if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
7501 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
7502 }
7503 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
7504 expr_ptr = *expr_ptr_ptr;
7505 Z_ADDREF_P(expr_ptr);
7506 } else {
7507 expr_ptr=opline->op1.zv;
7508 if (0) { /* temporary variable */
7509 zval *new_expr;
7510
7511 ALLOC_ZVAL(new_expr);
7512 INIT_PZVAL_COPY(new_expr, expr_ptr);
7513 expr_ptr = new_expr;
7514 } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
7515 zval *new_expr;
7516
7517 ALLOC_ZVAL(new_expr);
7518 INIT_PZVAL_COPY(new_expr, expr_ptr);
7519 expr_ptr = new_expr;
7520 zendi_zval_copy_ctor(*expr_ptr);
7521
7522 } else if (IS_CONST == IS_CV) {
7523 Z_ADDREF_P(expr_ptr);
7524 }
7525 }
7526
7527 if (IS_CV != IS_UNUSED) {
7528
7529 zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
7530 ulong hval;
7531
7532 switch (Z_TYPE_P(offset)) {
7533 case IS_DOUBLE:
7534 hval = zend_dval_to_lval(Z_DVAL_P(offset));
7535 goto num_index;
7536 case IS_LONG:
7537 case IS_BOOL:
7538 hval = Z_LVAL_P(offset);
7539 num_index:
7540 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
7541 break;
7542 case IS_STRING:
7543 if (IS_CV == IS_CONST) {
7544 hval = Z_HASH_P(offset);
7545 } else {
7546 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
7547 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
7548 }
7549 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
7550 break;
7551 case IS_NULL:
7552 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
7553 break;
7554 default:
7555 zend_error(E_WARNING, "Illegal offset type");
7556 zval_ptr_dtor(&expr_ptr);
7557 /* do nothing */
7558 break;
7559 }
7560
7561 } else {
7562 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
7563 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
7564 zval_ptr_dtor(&expr_ptr);
7565 }
7566 }
7567 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
7568
7569 }
7570 CHECK_EXCEPTION();
7571 ZEND_VM_NEXT_OPCODE();
7572 }
7573
ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7574 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7575 {
7576 USE_OPLINE
7577
7578 array_init(&EX_T(opline->result.var).tmp_var);
7579 if (IS_CONST == IS_UNUSED) {
7580 ZEND_VM_NEXT_OPCODE();
7581 #if 0 || IS_CONST != IS_UNUSED
7582 } else {
7583 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7584 #endif
7585 }
7586 }
7587
ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7588 static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7589 {
7590 USE_OPLINE
7591
7592 /* The generator object is stored in return_value_ptr_ptr */
7593 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
7594
7595 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
7596 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
7597 }
7598
7599 /* Destroy the previously yielded value */
7600 if (generator->value) {
7601 zval_ptr_dtor(&generator->value);
7602 }
7603
7604 /* Destroy the previously yielded key */
7605 if (generator->key) {
7606 zval_ptr_dtor(&generator->key);
7607 }
7608
7609 /* Set the new yielded value */
7610 if (IS_CONST != IS_UNUSED) {
7611
7612
7613 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
7614 /* Constants and temporary variables aren't yieldable by reference,
7615 * but we still allow them with a notice. */
7616 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
7617 zval *value, *copy;
7618
7619 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
7620
7621 value = opline->op1.zv;
7622 ALLOC_ZVAL(copy);
7623 INIT_PZVAL_COPY(copy, value);
7624
7625 /* Temporary variables don't need ctor copying */
7626 if (!0) {
7627 zval_copy_ctor(copy);
7628 }
7629
7630 generator->value = copy;
7631 } else {
7632 zval **value_ptr = NULL;
7633
7634 if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
7635 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
7636 }
7637
7638 /* If a function call result is yielded and the function did
7639 * not return by reference we throw a notice. */
7640 if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
7641 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
7642 && EX_T(opline->op1.var).var.fcall_returned_reference)
7643 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
7644 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
7645
7646 Z_ADDREF_PP(value_ptr);
7647 generator->value = *value_ptr;
7648 } else {
7649 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
7650 Z_ADDREF_PP(value_ptr);
7651 generator->value = *value_ptr;
7652 }
7653
7654 }
7655 } else {
7656 zval *value = opline->op1.zv;
7657
7658 /* Consts, temporary variables and references need copying */
7659 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
7660 || PZVAL_IS_REF(value)
7661 ) {
7662 zval *copy;
7663
7664 ALLOC_ZVAL(copy);
7665 INIT_PZVAL_COPY(copy, value);
7666
7667 /* Temporary variables don't need ctor copying */
7668 if (!0) {
7669 zval_copy_ctor(copy);
7670 }
7671
7672 generator->value = copy;
7673
7674 } else {
7675 if (IS_CONST == IS_CV) {
7676 Z_ADDREF_P(value);
7677 }
7678 generator->value = value;
7679 }
7680 }
7681 } else {
7682 /* If no value was specified yield null */
7683 Z_ADDREF(EG(uninitialized_zval));
7684 generator->value = &EG(uninitialized_zval);
7685 }
7686
7687 /* Set the new yielded key */
7688 if (IS_CV != IS_UNUSED) {
7689
7690 zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
7691
7692 /* Consts, temporary variables and references need copying */
7693 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
7694 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
7695 ) {
7696 zval *copy;
7697
7698 ALLOC_ZVAL(copy);
7699 INIT_PZVAL_COPY(copy, key);
7700
7701 /* Temporary variables don't need ctor copying */
7702 if (!0) {
7703 zval_copy_ctor(copy);
7704 }
7705
7706 generator->key = copy;
7707 } else {
7708 Z_ADDREF_P(key);
7709 generator->key = key;
7710 }
7711
7712 if (Z_TYPE_P(generator->key) == IS_LONG
7713 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
7714 ) {
7715 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
7716 }
7717
7718 } else {
7719 /* If no key was specified we use auto-increment keys */
7720 generator->largest_used_integer_key++;
7721
7722 ALLOC_INIT_ZVAL(generator->key);
7723 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
7724 }
7725
7726 if (RETURN_VALUE_USED(opline)) {
7727 /* If the return value of yield is used set the send
7728 * target and initialize it to NULL */
7729 generator->send_target = &EX_T(opline->result.var).var.ptr;
7730 Z_ADDREF(EG(uninitialized_zval));
7731 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
7732 } else {
7733 generator->send_target = NULL;
7734 }
7735
7736 /* We increment to the next op, so we are at the correct position when the
7737 * generator is resumed. */
7738 ZEND_VM_INC_OPCODE();
7739
7740 /* The GOTO VM uses a local opline variable. We need to set the opline
7741 * variable in execute_data so we don't resume at an old position. */
7742 SAVE_OPLINE();
7743
7744 ZEND_VM_RETURN();
7745 }
7746
ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7747 static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7748 {
7749 USE_OPLINE
7750
7751
7752 SAVE_OPLINE();
7753 pow_function(&EX_T(opline->result.var).tmp_var,
7754 opline->op1.zv,
7755 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7756
7757
7758 CHECK_EXCEPTION();
7759 ZEND_VM_NEXT_OPCODE();
7760 }
7761
ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7762 static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7763 {
7764 USE_OPLINE
7765 zend_free_op free_op1;
7766
7767 SAVE_OPLINE();
7768 bitwise_not_function(&EX_T(opline->result.var).tmp_var,
7769 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
7770 zval_dtor(free_op1.var);
7771 CHECK_EXCEPTION();
7772 ZEND_VM_NEXT_OPCODE();
7773 }
7774
ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7775 static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7776 {
7777 USE_OPLINE
7778 zend_free_op free_op1;
7779
7780 SAVE_OPLINE();
7781 boolean_not_function(&EX_T(opline->result.var).tmp_var,
7782 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
7783 zval_dtor(free_op1.var);
7784 CHECK_EXCEPTION();
7785 ZEND_VM_NEXT_OPCODE();
7786 }
7787
ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7788 static int ZEND_FASTCALL ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7789 {
7790 USE_OPLINE
7791 zend_free_op free_op1;
7792 zval *z;
7793
7794 SAVE_OPLINE();
7795 z = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7796
7797 if (IS_TMP_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
7798 INIT_PZVAL(z);
7799 }
7800 zend_print_variable(z);
7801
7802 zval_dtor(free_op1.var);
7803 CHECK_EXCEPTION();
7804 ZEND_VM_NEXT_OPCODE();
7805 }
7806
ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7807 static int ZEND_FASTCALL ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7808 {
7809 USE_OPLINE
7810
7811 ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
7812 return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7813 }
7814
ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7815 static int ZEND_FASTCALL ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7816 {
7817 USE_OPLINE
7818 zend_free_op free_op1;
7819 zval *val;
7820 int ret;
7821
7822 SAVE_OPLINE();
7823 val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7824
7825 if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
7826 ret = Z_LVAL_P(val);
7827 } else {
7828 ret = i_zend_is_true(val);
7829 zval_dtor(free_op1.var);
7830 if (UNEXPECTED(EG(exception) != NULL)) {
7831 HANDLE_EXCEPTION();
7832 }
7833 }
7834 if (!ret) {
7835 #if DEBUG_ZEND>=2
7836 printf("Conditional jmp to %d\n", opline->op2.opline_num);
7837 #endif
7838 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
7839 ZEND_VM_CONTINUE();
7840 }
7841
7842 ZEND_VM_NEXT_OPCODE();
7843 }
7844
ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7845 static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7846 {
7847 USE_OPLINE
7848 zend_free_op free_op1;
7849 zval *val;
7850 int ret;
7851
7852 SAVE_OPLINE();
7853 val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7854
7855 if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
7856 ret = Z_LVAL_P(val);
7857 } else {
7858 ret = i_zend_is_true(val);
7859 zval_dtor(free_op1.var);
7860 if (UNEXPECTED(EG(exception) != NULL)) {
7861 HANDLE_EXCEPTION();
7862 }
7863 }
7864 if (ret) {
7865 #if DEBUG_ZEND>=2
7866 printf("Conditional jmp to %d\n", opline->op2.opline_num);
7867 #endif
7868 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
7869 ZEND_VM_CONTINUE();
7870 }
7871
7872 ZEND_VM_NEXT_OPCODE();
7873 }
7874
ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7875 static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7876 {
7877 USE_OPLINE
7878 zend_free_op free_op1;
7879 zval *val;
7880 int retval;
7881
7882 SAVE_OPLINE();
7883 val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7884
7885 if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
7886 retval = Z_LVAL_P(val);
7887 } else {
7888 retval = i_zend_is_true(val);
7889 zval_dtor(free_op1.var);
7890 if (UNEXPECTED(EG(exception) != NULL)) {
7891 HANDLE_EXCEPTION();
7892 }
7893 }
7894 if (EXPECTED(retval != 0)) {
7895 #if DEBUG_ZEND>=2
7896 printf("Conditional jmp on true to %d\n", opline->extended_value);
7897 #endif
7898 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
7899 ZEND_VM_CONTINUE(); /* CHECK_ME */
7900 } else {
7901 #if DEBUG_ZEND>=2
7902 printf("Conditional jmp on false to %d\n", opline->op2.opline_num);
7903 #endif
7904 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
7905 ZEND_VM_CONTINUE(); /* CHECK_ME */
7906 }
7907 }
7908
ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7909 static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7910 {
7911 USE_OPLINE
7912 zend_free_op free_op1;
7913 zval *val;
7914 int retval;
7915
7916 SAVE_OPLINE();
7917 val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7918
7919 if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
7920 retval = Z_LVAL_P(val);
7921 } else {
7922 retval = i_zend_is_true(val);
7923 zval_dtor(free_op1.var);
7924 if (UNEXPECTED(EG(exception) != NULL)) {
7925 HANDLE_EXCEPTION();
7926 }
7927 }
7928 Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
7929 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
7930 if (!retval) {
7931 #if DEBUG_ZEND>=2
7932 printf("Conditional jmp to %d\n", opline->op2.opline_num);
7933 #endif
7934 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
7935 ZEND_VM_CONTINUE();
7936 }
7937 ZEND_VM_NEXT_OPCODE();
7938 }
7939
ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7940 static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7941 {
7942 USE_OPLINE
7943 zend_free_op free_op1;
7944 zval *val;
7945 int retval;
7946
7947 SAVE_OPLINE();
7948 val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7949
7950 if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
7951 retval = Z_LVAL_P(val);
7952 } else {
7953 retval = i_zend_is_true(val);
7954 zval_dtor(free_op1.var);
7955 if (UNEXPECTED(EG(exception) != NULL)) {
7956 HANDLE_EXCEPTION();
7957 }
7958 }
7959 Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
7960 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
7961 if (retval) {
7962 #if DEBUG_ZEND>=2
7963 printf("Conditional jmp to %d\n", opline->op2.opline_num);
7964 #endif
7965 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
7966 ZEND_VM_CONTINUE();
7967 }
7968 ZEND_VM_NEXT_OPCODE();
7969 }
7970
ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7971 static int ZEND_FASTCALL ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7972 {
7973 USE_OPLINE
7974
7975 SAVE_OPLINE();
7976 if (IS_TMP_VAR == IS_TMP_VAR) {
7977 zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
7978 } else {
7979 zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
7980 }
7981 CHECK_EXCEPTION();
7982 ZEND_VM_NEXT_OPCODE();
7983 }
7984
ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7985 static int ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7986 {
7987 USE_OPLINE
7988 zval *retval_ptr;
7989 zend_free_op free_op1;
7990
7991 SAVE_OPLINE();
7992 retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7993
7994 if (!EG(return_value_ptr_ptr)) {
7995 zval_dtor(free_op1.var);
7996 } else {
7997 if (IS_TMP_VAR == IS_CONST ||
7998 IS_TMP_VAR == IS_TMP_VAR ||
7999 PZVAL_IS_REF(retval_ptr)) {
8000 zval *ret;
8001
8002 ALLOC_ZVAL(ret);
8003 INIT_PZVAL_COPY(ret, retval_ptr);
8004 if (IS_TMP_VAR != IS_TMP_VAR) {
8005 zval_copy_ctor(ret);
8006 }
8007 *EG(return_value_ptr_ptr) = ret;
8008
8009 } else if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) &&
8010 retval_ptr == &EG(uninitialized_zval)) {
8011 zval *ret;
8012
8013 if (IS_TMP_VAR == IS_VAR) {
8014 Z_DELREF_P(retval_ptr);
8015 }
8016 ALLOC_INIT_ZVAL(ret);
8017 *EG(return_value_ptr_ptr) = ret;
8018 } else {
8019 *EG(return_value_ptr_ptr) = retval_ptr;
8020 if (IS_TMP_VAR == IS_CV) {
8021 Z_ADDREF_P(retval_ptr);
8022 }
8023 }
8024 }
8025 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8026 }
8027
ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8028 static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8029 {
8030 USE_OPLINE
8031 zval *retval_ptr;
8032 zval **retval_ptr_ptr;
8033 zend_free_op free_op1;
8034
8035 SAVE_OPLINE();
8036
8037 do {
8038 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR ||
8039 (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
8040 /* Not supposed to happen, but we'll allow it */
8041 zend_error(E_NOTICE, "Only variable references should be returned by reference");
8042
8043 retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8044 if (!EG(return_value_ptr_ptr)) {
8045 if (IS_TMP_VAR == IS_TMP_VAR) {
8046 zval_dtor(free_op1.var);
8047 }
8048 } else if (!1) { /* Not a temp var */
8049 zval *ret;
8050
8051 ALLOC_ZVAL(ret);
8052 INIT_PZVAL_COPY(ret, retval_ptr);
8053 zval_copy_ctor(ret);
8054 *EG(return_value_ptr_ptr) = ret;
8055 } else {
8056 zval *ret;
8057
8058 ALLOC_ZVAL(ret);
8059 INIT_PZVAL_COPY(ret, retval_ptr);
8060 *EG(return_value_ptr_ptr) = ret;
8061 }
8062 break;
8063 }
8064
8065 retval_ptr_ptr = NULL;
8066
8067 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
8068 zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
8069 }
8070
8071 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
8072 if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
8073 EX_T(opline->op1.var).var.fcall_returned_reference) {
8074 } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
8075 zend_error(E_NOTICE, "Only variable references should be returned by reference");
8076 if (EG(return_value_ptr_ptr)) {
8077 zval *ret;
8078
8079 ALLOC_ZVAL(ret);
8080 INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
8081 zval_copy_ctor(ret);
8082 *EG(return_value_ptr_ptr) = ret;
8083 }
8084 break;
8085 }
8086 }
8087
8088 if (EG(return_value_ptr_ptr)) {
8089 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
8090 Z_ADDREF_PP(retval_ptr_ptr);
8091
8092 *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
8093 }
8094 } while (0);
8095
8096 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8097 }
8098
ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8099 static int ZEND_FASTCALL ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8100 {
8101 USE_OPLINE
8102 zval *value;
8103 zval *exception;
8104 zend_free_op free_op1;
8105
8106 SAVE_OPLINE();
8107 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8108
8109 if (IS_TMP_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
8110 if (UNEXPECTED(EG(exception) != NULL)) {
8111 HANDLE_EXCEPTION();
8112 }
8113 zend_error_noreturn(E_ERROR, "Can only throw objects");
8114 }
8115
8116 zend_exception_save(TSRMLS_C);
8117 /* Not sure if a complete copy is what we want here */
8118 ALLOC_ZVAL(exception);
8119 INIT_PZVAL_COPY(exception, value);
8120 if (!1) {
8121 zval_copy_ctor(exception);
8122 }
8123
8124 zend_throw_exception_object(exception TSRMLS_CC);
8125 zend_exception_restore(TSRMLS_C);
8126
8127 HANDLE_EXCEPTION();
8128 }
8129
ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8130 static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8131 {
8132 USE_OPLINE
8133
8134 SAVE_OPLINE();
8135 if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
8136 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
8137 zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.num);
8138 }
8139 }
8140
8141 {
8142 zval *valptr;
8143 zval *value;
8144 zend_free_op free_op1;
8145
8146 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8147
8148 ALLOC_ZVAL(valptr);
8149 INIT_PZVAL_COPY(valptr, value);
8150 if (!1) {
8151 zval_copy_ctor(valptr);
8152 }
8153 zend_vm_stack_push(valptr TSRMLS_CC);
8154
8155 }
8156 CHECK_EXCEPTION();
8157 ZEND_VM_NEXT_OPCODE();
8158 }
8159
ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8160 static int ZEND_FASTCALL ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8161 {
8162 USE_OPLINE
8163 zend_free_op free_op1;
8164 zval *retval = &EX_T(opline->result.var).tmp_var;
8165
8166 SAVE_OPLINE();
8167 /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
8168 ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)));
8169 zval_dtor(free_op1.var);
8170
8171 CHECK_EXCEPTION();
8172 ZEND_VM_NEXT_OPCODE();
8173 }
8174
ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8175 static int ZEND_FASTCALL ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8176 {
8177 USE_OPLINE
8178 zend_free_op free_op1;
8179 zval *obj;
8180 zend_class_entry *ce;
8181 zend_function *clone;
8182 zend_object_clone_obj_t clone_call;
8183
8184 SAVE_OPLINE();
8185 obj = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8186
8187 if (IS_TMP_VAR == IS_CONST ||
8188 UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
8189 if (UNEXPECTED(EG(exception) != NULL)) {
8190 HANDLE_EXCEPTION();
8191 }
8192 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
8193 }
8194
8195 ce = Z_OBJCE_P(obj);
8196 clone = ce ? ce->clone : NULL;
8197 clone_call = Z_OBJ_HT_P(obj)->clone_obj;
8198 if (UNEXPECTED(clone_call == NULL)) {
8199 if (ce) {
8200 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
8201 } else {
8202 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
8203 }
8204 }
8205
8206 if (ce && clone) {
8207 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
8208 /* Ensure that if we're calling a private function, we're allowed to do so.
8209 */
8210 if (UNEXPECTED(ce != EG(scope))) {
8211 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
8212 }
8213 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
8214 /* Ensure that if we're calling a protected function, we're allowed to do so.
8215 */
8216 if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
8217 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
8218 }
8219 }
8220 }
8221
8222 if (EXPECTED(EG(exception) == NULL)) {
8223 zval *retval;
8224
8225 ALLOC_ZVAL(retval);
8226 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
8227 Z_TYPE_P(retval) = IS_OBJECT;
8228 Z_SET_REFCOUNT_P(retval, 1);
8229 Z_SET_ISREF_P(retval);
8230 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
8231 zval_ptr_dtor(&retval);
8232 } else {
8233 EX_T(opline->result.var).var.ptr = retval;
8234 }
8235 }
8236
8237 CHECK_EXCEPTION();
8238 ZEND_VM_NEXT_OPCODE();
8239 }
8240
ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8241 static int ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8242 {
8243 USE_OPLINE
8244 zend_free_op free_op1;
8245 zval *expr;
8246 zval *result = &EX_T(opline->result.var).tmp_var;
8247
8248 SAVE_OPLINE();
8249 expr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8250
8251 if (opline->extended_value != IS_STRING) {
8252 ZVAL_COPY_VALUE(result, expr);
8253 if (!1) {
8254 zendi_zval_copy_ctor(*result);
8255 }
8256 }
8257 switch (opline->extended_value) {
8258 case IS_NULL:
8259 convert_to_null(result);
8260 break;
8261 case IS_BOOL:
8262 convert_to_boolean(result);
8263 break;
8264 case IS_LONG:
8265 convert_to_long(result);
8266 break;
8267 case IS_DOUBLE:
8268 convert_to_double(result);
8269 break;
8270 case IS_STRING: {
8271 zval var_copy;
8272 int use_copy;
8273
8274 zend_make_printable_zval(expr, &var_copy, &use_copy);
8275 if (use_copy) {
8276 ZVAL_COPY_VALUE(result, &var_copy);
8277 if (1) {
8278 zval_dtor(free_op1.var);
8279 }
8280 } else {
8281 ZVAL_COPY_VALUE(result, expr);
8282 if (!1) {
8283 zendi_zval_copy_ctor(*result);
8284 }
8285 }
8286 break;
8287 }
8288 case IS_ARRAY:
8289 convert_to_array(result);
8290 break;
8291 case IS_OBJECT:
8292 convert_to_object(result);
8293 break;
8294 }
8295
8296 CHECK_EXCEPTION();
8297 ZEND_VM_NEXT_OPCODE();
8298 }
8299
ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8300 static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8301 {
8302 USE_OPLINE
8303 zend_op_array *new_op_array=NULL;
8304 zend_free_op free_op1;
8305 zval *inc_filename;
8306 zval *tmp_inc_filename = NULL;
8307 zend_bool failure_retval=0;
8308
8309 SAVE_OPLINE();
8310 inc_filename = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8311
8312 if (inc_filename->type!=IS_STRING) {
8313 MAKE_STD_ZVAL(tmp_inc_filename);
8314 ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
8315 zval_copy_ctor(tmp_inc_filename);
8316 convert_to_string(tmp_inc_filename);
8317 inc_filename = tmp_inc_filename;
8318 }
8319
8320 if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
8321 if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
8322 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
8323 } else {
8324 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
8325 }
8326 } else {
8327 switch (opline->extended_value) {
8328 case ZEND_INCLUDE_ONCE:
8329 case ZEND_REQUIRE_ONCE: {
8330 zend_file_handle file_handle;
8331 char *resolved_path;
8332
8333 resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
8334 if (resolved_path) {
8335 failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
8336 } else {
8337 resolved_path = Z_STRVAL_P(inc_filename);
8338 }
8339
8340 if (failure_retval) {
8341 /* do nothing, file already included */
8342 } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
8343
8344 if (!file_handle.opened_path) {
8345 file_handle.opened_path = estrdup(resolved_path);
8346 }
8347
8348 if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
8349 new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
8350 zend_destroy_file_handle(&file_handle TSRMLS_CC);
8351 } else {
8352 zend_file_handle_dtor(&file_handle TSRMLS_CC);
8353 failure_retval=1;
8354 }
8355 } else {
8356 if (opline->extended_value == ZEND_INCLUDE_ONCE) {
8357 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
8358 } else {
8359 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
8360 }
8361 }
8362 if (resolved_path != Z_STRVAL_P(inc_filename)) {
8363 efree(resolved_path);
8364 }
8365 }
8366 break;
8367 case ZEND_INCLUDE:
8368 case ZEND_REQUIRE:
8369 new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC);
8370 break;
8371 case ZEND_EVAL: {
8372 char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
8373
8374 new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
8375 efree(eval_desc);
8376 }
8377 break;
8378 EMPTY_SWITCH_DEFAULT_CASE()
8379 }
8380 }
8381 if (tmp_inc_filename) {
8382 zval_ptr_dtor(&tmp_inc_filename);
8383 }
8384 zval_dtor(free_op1.var);
8385 if (UNEXPECTED(EG(exception) != NULL)) {
8386 HANDLE_EXCEPTION();
8387 } else if (EXPECTED(new_op_array != NULL)) {
8388 EX(original_return_value) = EG(return_value_ptr_ptr);
8389 EG(active_op_array) = new_op_array;
8390 if (RETURN_VALUE_USED(opline)) {
8391 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
8392 EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
8393 } else {
8394 EG(return_value_ptr_ptr) = NULL;
8395 }
8396
8397 EX(function_state).function = (zend_function *) new_op_array;
8398 EX(object) = NULL;
8399
8400 if (!EG(active_symbol_table)) {
8401 zend_rebuild_symbol_table(TSRMLS_C);
8402 }
8403
8404 if (EXPECTED(zend_execute_ex == execute_ex)) {
8405 ZEND_VM_ENTER();
8406 } else {
8407 zend_execute(new_op_array TSRMLS_CC);
8408 }
8409
8410 EX(function_state).function = (zend_function *) EX(op_array);
8411
8412 EG(opline_ptr) = &EX(opline);
8413 EG(active_op_array) = EX(op_array);
8414 EG(return_value_ptr_ptr) = EX(original_return_value);
8415 destroy_op_array(new_op_array TSRMLS_CC);
8416 efree(new_op_array);
8417 if (UNEXPECTED(EG(exception) != NULL)) {
8418 zend_throw_exception_internal(NULL TSRMLS_CC);
8419 HANDLE_EXCEPTION();
8420 }
8421
8422 } else if (RETURN_VALUE_USED(opline)) {
8423 zval *retval;
8424
8425 ALLOC_ZVAL(retval);
8426 ZVAL_BOOL(retval, failure_retval);
8427 INIT_PZVAL(retval);
8428 EX_T(opline->result.var).var.ptr = retval;
8429 }
8430 ZEND_VM_NEXT_OPCODE();
8431 }
8432
ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8433 static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8434 {
8435 USE_OPLINE
8436 zend_free_op free_op1;
8437 zval *array_ptr, **array_ptr_ptr;
8438 HashTable *fe_ht;
8439 zend_object_iterator *iter = NULL;
8440 zend_class_entry *ce = NULL;
8441 zend_bool is_empty = 0;
8442
8443 SAVE_OPLINE();
8444
8445 if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) &&
8446 (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
8447 array_ptr_ptr = NULL;
8448 if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
8449 MAKE_STD_ZVAL(array_ptr);
8450 ZVAL_NULL(array_ptr);
8451 } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
8452 if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
8453 zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
8454 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
8455 }
8456
8457 ce = Z_OBJCE_PP(array_ptr_ptr);
8458 if (!ce || ce->get_iterator == NULL) {
8459 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
8460 Z_ADDREF_PP(array_ptr_ptr);
8461 }
8462 array_ptr = *array_ptr_ptr;
8463 } else {
8464 if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
8465 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
8466 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
8467 Z_SET_ISREF_PP(array_ptr_ptr);
8468 }
8469 }
8470 array_ptr = *array_ptr_ptr;
8471 Z_ADDREF_P(array_ptr);
8472 }
8473 } else {
8474 array_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8475 if (1) { /* IS_TMP_VAR */
8476 zval *tmp;
8477
8478 ALLOC_ZVAL(tmp);
8479 INIT_PZVAL_COPY(tmp, array_ptr);
8480 array_ptr = tmp;
8481 if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
8482 ce = Z_OBJCE_P(array_ptr);
8483 if (ce && ce->get_iterator) {
8484 Z_DELREF_P(array_ptr);
8485 }
8486 }
8487 } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
8488 ce = Z_OBJCE_P(array_ptr);
8489 if (!ce || !ce->get_iterator) {
8490 if (IS_TMP_VAR == IS_CV) {
8491 Z_ADDREF_P(array_ptr);
8492 }
8493 }
8494 } else if (IS_TMP_VAR == IS_CONST ||
8495 (IS_TMP_VAR == IS_CV &&
8496 !Z_ISREF_P(array_ptr) &&
8497 Z_REFCOUNT_P(array_ptr) > 1) ||
8498 (IS_TMP_VAR == IS_VAR &&
8499 !Z_ISREF_P(array_ptr) &&
8500 Z_REFCOUNT_P(array_ptr) > 2)) {
8501 zval *tmp;
8502
8503 if (IS_TMP_VAR == IS_VAR) {
8504 Z_DELREF_P(array_ptr);
8505 }
8506 ALLOC_ZVAL(tmp);
8507 INIT_PZVAL_COPY(tmp, array_ptr);
8508 zval_copy_ctor(tmp);
8509 array_ptr = tmp;
8510 } else if (IS_TMP_VAR == IS_CV) {
8511 Z_ADDREF_P(array_ptr);
8512 }
8513 }
8514
8515 if (ce && ce->get_iterator) {
8516 iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
8517
8518 if (IS_TMP_VAR == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
8519
8520 }
8521 if (iter && EXPECTED(EG(exception) == NULL)) {
8522 array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
8523 } else {
8524 if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8525
8526 }
8527 if (!EG(exception)) {
8528 zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
8529 }
8530 zend_throw_exception_internal(NULL TSRMLS_CC);
8531 HANDLE_EXCEPTION();
8532 }
8533 }
8534
8535 EX_T(opline->result.var).fe.ptr = array_ptr;
8536
8537 if (iter) {
8538 iter->index = 0;
8539 if (iter->funcs->rewind) {
8540 iter->funcs->rewind(iter TSRMLS_CC);
8541 if (UNEXPECTED(EG(exception) != NULL)) {
8542 zval_ptr_dtor(&array_ptr);
8543 if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8544
8545 }
8546 HANDLE_EXCEPTION();
8547 }
8548 }
8549 is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
8550 if (UNEXPECTED(EG(exception) != NULL)) {
8551 zval_ptr_dtor(&array_ptr);
8552 if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8553
8554 }
8555 HANDLE_EXCEPTION();
8556 }
8557 iter->index = -1; /* will be set to 0 before using next handler */
8558 } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
8559 zend_hash_internal_pointer_reset(fe_ht);
8560 if (ce) {
8561 zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
8562 while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
8563 char *str_key;
8564 uint str_key_len;
8565 ulong int_key;
8566 zend_uchar key_type;
8567
8568 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
8569 if (key_type != HASH_KEY_NON_EXISTENT &&
8570 (key_type == HASH_KEY_IS_LONG ||
8571 zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
8572 break;
8573 }
8574 zend_hash_move_forward(fe_ht);
8575 }
8576 }
8577 is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
8578 zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
8579 } else {
8580 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
8581 is_empty = 1;
8582 }
8583
8584 if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8585
8586 }
8587 if (is_empty) {
8588 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
8589 } else {
8590 CHECK_EXCEPTION();
8591 ZEND_VM_NEXT_OPCODE();
8592 }
8593 }
8594
ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8595 static int ZEND_FASTCALL ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8596 {
8597 #if 0 || (IS_TMP_VAR != IS_UNUSED)
8598 USE_OPLINE
8599
8600 SAVE_OPLINE();
8601 if (IS_TMP_VAR != IS_UNUSED) {
8602 zend_free_op free_op1;
8603 zval *ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8604
8605 if (Z_TYPE_P(ptr) == IS_LONG) {
8606 EG(exit_status) = Z_LVAL_P(ptr);
8607 } else {
8608 zend_print_variable(ptr);
8609 }
8610 zval_dtor(free_op1.var);
8611 }
8612 #endif
8613 zend_bailout();
8614 ZEND_VM_NEXT_OPCODE(); /* Never reached */
8615 }
8616
ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8617 static int ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8618 {
8619 USE_OPLINE
8620 zval restored_error_reporting;
8621
8622 SAVE_OPLINE();
8623 if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.var).tmp_var) != 0) {
8624 Z_TYPE(restored_error_reporting) = IS_LONG;
8625 Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.var).tmp_var);
8626 EG(error_reporting) = Z_LVAL(restored_error_reporting);
8627 convert_to_string(&restored_error_reporting);
8628 if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) {
8629 if (EXPECTED(EG(error_reporting_ini_entry)->modified &&
8630 EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value)) {
8631 efree(EG(error_reporting_ini_entry)->value);
8632 }
8633 EG(error_reporting_ini_entry)->value = Z_STRVAL(restored_error_reporting);
8634 EG(error_reporting_ini_entry)->value_length = Z_STRLEN(restored_error_reporting);
8635 } else {
8636 zendi_zval_dtor(restored_error_reporting);
8637 }
8638 }
8639 if (EX(old_error_reporting) == &EX_T(opline->op1.var).tmp_var) {
8640 EX(old_error_reporting) = NULL;
8641 }
8642 CHECK_EXCEPTION();
8643 ZEND_VM_NEXT_OPCODE();
8644 }
8645
ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8646 static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8647 {
8648 USE_OPLINE
8649 zend_free_op free_op1;
8650 zval *value;
8651
8652 SAVE_OPLINE();
8653 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8654
8655 if (i_zend_is_true(value)) {
8656 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
8657 if (!1) {
8658 zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
8659 }
8660
8661 #if DEBUG_ZEND>=2
8662 printf("Conditional jmp to %d\n", opline->op2.opline_num);
8663 #endif
8664 ZEND_VM_JMP(opline->op2.jmp_addr);
8665 }
8666
8667 zval_dtor(free_op1.var);
8668 CHECK_EXCEPTION();
8669 ZEND_VM_NEXT_OPCODE();
8670 }
8671
ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8672 static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8673 {
8674 USE_OPLINE
8675 zend_free_op free_op1;
8676 zval *value, *ret;
8677
8678 SAVE_OPLINE();
8679 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8680
8681 if (i_zend_is_true(value)) {
8682 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
8683 Z_ADDREF_P(value);
8684 EX_T(opline->result.var).var.ptr = value;
8685 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
8686 } else {
8687 ALLOC_ZVAL(ret);
8688 INIT_PZVAL_COPY(ret, value);
8689 EX_T(opline->result.var).var.ptr = ret;
8690 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
8691 if (!1) {
8692 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
8693 }
8694 }
8695
8696 #if DEBUG_ZEND>=2
8697 printf("Conditional jmp to %d\n", opline->op2.opline_num);
8698 #endif
8699 ZEND_VM_JMP(opline->op2.jmp_addr);
8700 }
8701
8702 zval_dtor(free_op1.var);
8703 CHECK_EXCEPTION();
8704 ZEND_VM_NEXT_OPCODE();
8705 }
8706
ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8707 static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8708 {
8709 USE_OPLINE
8710 zend_free_op free_op1;
8711 zval *value;
8712
8713 SAVE_OPLINE();
8714 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8715
8716 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
8717 if (!1) {
8718 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
8719 }
8720
8721 CHECK_EXCEPTION();
8722 ZEND_VM_NEXT_OPCODE();
8723 }
8724
ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8725 static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8726 {
8727 USE_OPLINE
8728 zend_free_op free_op1;
8729 zval *value, *ret;
8730
8731 SAVE_OPLINE();
8732 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8733
8734 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
8735 Z_ADDREF_P(value);
8736 EX_T(opline->result.var).var.ptr = value;
8737 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
8738 } else {
8739 ALLOC_ZVAL(ret);
8740 INIT_PZVAL_COPY(ret, value);
8741 EX_T(opline->result.var).var.ptr = ret;
8742 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
8743 if (!1) {
8744 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
8745 }
8746 }
8747
8748 CHECK_EXCEPTION();
8749 ZEND_VM_NEXT_OPCODE();
8750 }
8751
ZEND_INSTANCEOF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8752 static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8753 {
8754 USE_OPLINE
8755 zend_free_op free_op1;
8756 zval *expr;
8757 zend_bool result;
8758
8759 SAVE_OPLINE();
8760 expr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8761
8762 if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
8763 result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
8764 } else {
8765 result = 0;
8766 }
8767 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
8768 zval_dtor(free_op1.var);
8769 CHECK_EXCEPTION();
8770 ZEND_VM_NEXT_OPCODE();
8771 }
8772
ZEND_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8773 static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8774 {
8775 USE_OPLINE
8776 zend_free_op free_op1;
8777
8778 SAVE_OPLINE();
8779 fast_add_function(&EX_T(opline->result.var).tmp_var,
8780 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8781 opline->op2.zv TSRMLS_CC);
8782 zval_dtor(free_op1.var);
8783
8784 CHECK_EXCEPTION();
8785 ZEND_VM_NEXT_OPCODE();
8786 }
8787
ZEND_SUB_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8788 static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8789 {
8790 USE_OPLINE
8791 zend_free_op free_op1;
8792
8793 SAVE_OPLINE();
8794 fast_sub_function(&EX_T(opline->result.var).tmp_var,
8795 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8796 opline->op2.zv TSRMLS_CC);
8797 zval_dtor(free_op1.var);
8798
8799 CHECK_EXCEPTION();
8800 ZEND_VM_NEXT_OPCODE();
8801 }
8802
ZEND_MUL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8803 static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8804 {
8805 USE_OPLINE
8806 zend_free_op free_op1;
8807
8808 SAVE_OPLINE();
8809 fast_mul_function(&EX_T(opline->result.var).tmp_var,
8810 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8811 opline->op2.zv TSRMLS_CC);
8812 zval_dtor(free_op1.var);
8813
8814 CHECK_EXCEPTION();
8815 ZEND_VM_NEXT_OPCODE();
8816 }
8817
ZEND_DIV_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8818 static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8819 {
8820 USE_OPLINE
8821 zend_free_op free_op1;
8822
8823 SAVE_OPLINE();
8824 fast_div_function(&EX_T(opline->result.var).tmp_var,
8825 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8826 opline->op2.zv TSRMLS_CC);
8827 zval_dtor(free_op1.var);
8828
8829 CHECK_EXCEPTION();
8830 ZEND_VM_NEXT_OPCODE();
8831 }
8832
ZEND_MOD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8833 static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8834 {
8835 USE_OPLINE
8836 zend_free_op free_op1;
8837
8838 SAVE_OPLINE();
8839 fast_mod_function(&EX_T(opline->result.var).tmp_var,
8840 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8841 opline->op2.zv TSRMLS_CC);
8842 zval_dtor(free_op1.var);
8843
8844 CHECK_EXCEPTION();
8845 ZEND_VM_NEXT_OPCODE();
8846 }
8847
ZEND_SL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8848 static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8849 {
8850 USE_OPLINE
8851 zend_free_op free_op1;
8852
8853 SAVE_OPLINE();
8854 shift_left_function(&EX_T(opline->result.var).tmp_var,
8855 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8856 opline->op2.zv TSRMLS_CC);
8857 zval_dtor(free_op1.var);
8858
8859 CHECK_EXCEPTION();
8860 ZEND_VM_NEXT_OPCODE();
8861 }
8862
ZEND_SR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8863 static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8864 {
8865 USE_OPLINE
8866 zend_free_op free_op1;
8867
8868 SAVE_OPLINE();
8869 shift_right_function(&EX_T(opline->result.var).tmp_var,
8870 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8871 opline->op2.zv TSRMLS_CC);
8872 zval_dtor(free_op1.var);
8873
8874 CHECK_EXCEPTION();
8875 ZEND_VM_NEXT_OPCODE();
8876 }
8877
ZEND_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8878 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8879 {
8880 USE_OPLINE
8881 zend_free_op free_op1;
8882
8883 SAVE_OPLINE();
8884 concat_function(&EX_T(opline->result.var).tmp_var,
8885 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8886 opline->op2.zv TSRMLS_CC);
8887 zval_dtor(free_op1.var);
8888
8889 CHECK_EXCEPTION();
8890 ZEND_VM_NEXT_OPCODE();
8891 }
8892
ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8893 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8894 {
8895 USE_OPLINE
8896 zend_free_op free_op1;
8897
8898 SAVE_OPLINE();
8899 is_identical_function(&EX_T(opline->result.var).tmp_var,
8900 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8901 opline->op2.zv TSRMLS_CC);
8902 zval_dtor(free_op1.var);
8903
8904 CHECK_EXCEPTION();
8905 ZEND_VM_NEXT_OPCODE();
8906 }
8907
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8908 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8909 {
8910 USE_OPLINE
8911 zend_free_op free_op1;
8912 zval *result = &EX_T(opline->result.var).tmp_var;
8913
8914 SAVE_OPLINE();
8915 is_identical_function(result,
8916 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8917 opline->op2.zv TSRMLS_CC);
8918 Z_LVAL_P(result) = !Z_LVAL_P(result);
8919 zval_dtor(free_op1.var);
8920
8921 CHECK_EXCEPTION();
8922 ZEND_VM_NEXT_OPCODE();
8923 }
8924
ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8925 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8926 {
8927 USE_OPLINE
8928 zend_free_op free_op1;
8929 zval *result = &EX_T(opline->result.var).tmp_var;
8930
8931 SAVE_OPLINE();
8932 ZVAL_BOOL(result, fast_equal_function(result,
8933 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8934 opline->op2.zv TSRMLS_CC));
8935 zval_dtor(free_op1.var);
8936
8937 CHECK_EXCEPTION();
8938 ZEND_VM_NEXT_OPCODE();
8939 }
8940
ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8941 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8942 {
8943 USE_OPLINE
8944 zend_free_op free_op1;
8945 zval *result = &EX_T(opline->result.var).tmp_var;
8946
8947 SAVE_OPLINE();
8948 ZVAL_BOOL(result, fast_not_equal_function(result,
8949 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8950 opline->op2.zv TSRMLS_CC));
8951 zval_dtor(free_op1.var);
8952
8953 CHECK_EXCEPTION();
8954 ZEND_VM_NEXT_OPCODE();
8955 }
8956
ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8957 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8958 {
8959 USE_OPLINE
8960 zend_free_op free_op1;
8961 zval *result = &EX_T(opline->result.var).tmp_var;
8962
8963 SAVE_OPLINE();
8964 ZVAL_BOOL(result, fast_is_smaller_function(result,
8965 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8966 opline->op2.zv TSRMLS_CC));
8967 zval_dtor(free_op1.var);
8968
8969 CHECK_EXCEPTION();
8970 ZEND_VM_NEXT_OPCODE();
8971 }
8972
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8973 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8974 {
8975 USE_OPLINE
8976 zend_free_op free_op1;
8977 zval *result = &EX_T(opline->result.var).tmp_var;
8978
8979 SAVE_OPLINE();
8980 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
8981 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8982 opline->op2.zv TSRMLS_CC));
8983 zval_dtor(free_op1.var);
8984
8985 CHECK_EXCEPTION();
8986 ZEND_VM_NEXT_OPCODE();
8987 }
8988
ZEND_BW_OR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8989 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8990 {
8991 USE_OPLINE
8992 zend_free_op free_op1;
8993
8994 SAVE_OPLINE();
8995 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
8996 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8997 opline->op2.zv TSRMLS_CC);
8998 zval_dtor(free_op1.var);
8999
9000 CHECK_EXCEPTION();
9001 ZEND_VM_NEXT_OPCODE();
9002 }
9003
ZEND_BW_AND_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9004 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9005 {
9006 USE_OPLINE
9007 zend_free_op free_op1;
9008
9009 SAVE_OPLINE();
9010 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
9011 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9012 opline->op2.zv TSRMLS_CC);
9013 zval_dtor(free_op1.var);
9014
9015 CHECK_EXCEPTION();
9016 ZEND_VM_NEXT_OPCODE();
9017 }
9018
ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9019 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9020 {
9021 USE_OPLINE
9022 zend_free_op free_op1;
9023
9024 SAVE_OPLINE();
9025 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
9026 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9027 opline->op2.zv TSRMLS_CC);
9028 zval_dtor(free_op1.var);
9029
9030 CHECK_EXCEPTION();
9031 ZEND_VM_NEXT_OPCODE();
9032 }
9033
ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9034 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9035 {
9036 USE_OPLINE
9037 zend_free_op free_op1;
9038
9039 SAVE_OPLINE();
9040 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
9041 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9042 opline->op2.zv TSRMLS_CC);
9043 zval_dtor(free_op1.var);
9044
9045 CHECK_EXCEPTION();
9046 ZEND_VM_NEXT_OPCODE();
9047 }
9048
zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,ZEND_OPCODE_HANDLER_ARGS)9049 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
9050 {
9051 USE_OPLINE
9052 zend_free_op free_op1;
9053 zval *varname;
9054 zval **retval;
9055 zval tmp_varname;
9056 HashTable *target_symbol_table;
9057 ulong hash_value;
9058
9059 SAVE_OPLINE();
9060 varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9061
9062 if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
9063 ZVAL_COPY_VALUE(&tmp_varname, varname);
9064 zval_copy_ctor(&tmp_varname);
9065 Z_SET_REFCOUNT(tmp_varname, 1);
9066 Z_UNSET_ISREF(tmp_varname);
9067 convert_to_string(&tmp_varname);
9068 varname = &tmp_varname;
9069 }
9070
9071 if (IS_CONST != IS_UNUSED) {
9072 zend_class_entry *ce;
9073
9074 if (IS_CONST == IS_CONST) {
9075 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
9076 ce = CACHED_PTR(opline->op2.literal->cache_slot);
9077 } else {
9078 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
9079 if (UNEXPECTED(ce == NULL)) {
9080 if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
9081 zval_dtor(&tmp_varname);
9082 }
9083 zval_dtor(free_op1.var);
9084 CHECK_EXCEPTION();
9085 ZEND_VM_NEXT_OPCODE();
9086 }
9087 CACHE_PTR(opline->op2.literal->cache_slot, ce);
9088 }
9089 } else {
9090 ce = EX_T(opline->op2.var).class_entry;
9091 }
9092 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
9093 zval_dtor(free_op1.var);
9094 } else {
9095 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
9096 /*
9097 if (!target_symbol_table) {
9098 CHECK_EXCEPTION();
9099 ZEND_VM_NEXT_OPCODE();
9100 }
9101 */
9102 if (IS_TMP_VAR == IS_CONST) {
9103 hash_value = Z_HASH_P(varname);
9104 } else {
9105 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
9106 }
9107
9108 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
9109 switch (type) {
9110 case BP_VAR_R:
9111 case BP_VAR_UNSET:
9112 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
9113 /* break missing intentionally */
9114 case BP_VAR_IS:
9115 retval = &EG(uninitialized_zval_ptr);
9116 break;
9117 case BP_VAR_RW:
9118 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
9119 /* break missing intentionally */
9120 case BP_VAR_W:
9121 Z_ADDREF_P(&EG(uninitialized_zval));
9122 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
9123 break;
9124 EMPTY_SWITCH_DEFAULT_CASE()
9125 }
9126 }
9127 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
9128 case ZEND_FETCH_GLOBAL:
9129 if (IS_TMP_VAR != IS_TMP_VAR) {
9130 zval_dtor(free_op1.var);
9131 }
9132 break;
9133 case ZEND_FETCH_LOCAL:
9134 zval_dtor(free_op1.var);
9135 break;
9136 case ZEND_FETCH_STATIC:
9137 zval_update_constant(retval, 1 TSRMLS_CC);
9138 break;
9139 case ZEND_FETCH_GLOBAL_LOCK:
9140 if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
9141 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
9142 }
9143 break;
9144 }
9145 }
9146
9147
9148 if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
9149 zval_dtor(&tmp_varname);
9150 }
9151 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
9152 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
9153 }
9154 PZVAL_LOCK(*retval);
9155 switch (type) {
9156 case BP_VAR_R:
9157 case BP_VAR_IS:
9158 EX_T(opline->result.var).var.ptr = *retval;
9159 break;
9160 case BP_VAR_UNSET: {
9161 zend_free_op free_res;
9162
9163 PZVAL_UNLOCK(*retval, &free_res);
9164 if (retval != &EG(uninitialized_zval_ptr)) {
9165 SEPARATE_ZVAL_IF_NOT_REF(retval);
9166 }
9167 PZVAL_LOCK(*retval);
9168 FREE_OP_VAR_PTR(free_res);
9169 }
9170 /* break missing intentionally */
9171 default:
9172 EX_T(opline->result.var).var.ptr_ptr = retval;
9173 break;
9174 }
9175 CHECK_EXCEPTION();
9176 ZEND_VM_NEXT_OPCODE();
9177 }
9178
ZEND_FETCH_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9179 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9180 {
9181 return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9182 }
9183
ZEND_FETCH_W_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9184 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9185 {
9186 return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9187 }
9188
ZEND_FETCH_RW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9189 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9190 {
9191 return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9192 }
9193
ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9194 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9195 {
9196 USE_OPLINE
9197
9198 return zend_fetch_var_address_helper_SPEC_TMP_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9199 }
9200
ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9201 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9202 {
9203 return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9204 }
9205
ZEND_FETCH_IS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9206 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9207 {
9208 return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9209 }
9210
ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9211 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9212 {
9213 USE_OPLINE
9214 zend_free_op free_op1;
9215 zval *container;
9216
9217 SAVE_OPLINE();
9218 container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9219 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
9220
9221 if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
9222 zval_dtor(free_op1.var);
9223 }
9224 CHECK_EXCEPTION();
9225 ZEND_VM_NEXT_OPCODE();
9226 }
9227
ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9228 static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9229 {
9230 USE_OPLINE
9231 zend_free_op free_op1;
9232 zval *container;
9233
9234 SAVE_OPLINE();
9235 container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9236
9237 if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
9238 PZVAL_LOCK(&EG(uninitialized_zval));
9239 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
9240 } else {
9241
9242 zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
9243
9244 PZVAL_LOCK(value);
9245 EX_T(opline->result.var).var.ptr = value;
9246
9247 }
9248 CHECK_EXCEPTION();
9249 ZEND_VM_NEXT_OPCODE();
9250 }
9251
ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9252 static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9253 {
9254 USE_OPLINE
9255 zval *str = &EX_T(opline->result.var).tmp_var;
9256
9257 SAVE_OPLINE();
9258
9259 if (IS_TMP_VAR == IS_UNUSED) {
9260 /* Initialize for erealloc in add_char_to_string */
9261 Z_STRVAL_P(str) = NULL;
9262 Z_STRLEN_P(str) = 0;
9263 Z_TYPE_P(str) = IS_STRING;
9264
9265 INIT_PZVAL(str);
9266 }
9267
9268 add_char_to_string(str, str, opline->op2.zv);
9269
9270 /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
9271 /*CHECK_EXCEPTION();*/
9272 ZEND_VM_NEXT_OPCODE();
9273 }
9274
ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9275 static int ZEND_FASTCALL ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9276 {
9277 USE_OPLINE
9278 zval *str = &EX_T(opline->result.var).tmp_var;
9279
9280 SAVE_OPLINE();
9281
9282 if (IS_TMP_VAR == IS_UNUSED) {
9283 /* Initialize for erealloc in add_string_to_string */
9284 Z_STRVAL_P(str) = NULL;
9285 Z_STRLEN_P(str) = 0;
9286 Z_TYPE_P(str) = IS_STRING;
9287
9288 INIT_PZVAL(str);
9289 }
9290
9291 add_string_to_string(str, str, opline->op2.zv);
9292
9293 /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
9294 /*CHECK_EXCEPTION();*/
9295 ZEND_VM_NEXT_OPCODE();
9296 }
9297
ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9298 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9299 {
9300 USE_OPLINE
9301 zval *function_name;
9302 char *function_name_strval;
9303 int function_name_strlen;
9304 zend_free_op free_op1;
9305 call_slot *call = EX(call_slots) + opline->result.num;
9306
9307 SAVE_OPLINE();
9308
9309 function_name = opline->op2.zv;
9310
9311 if (IS_CONST != IS_CONST &&
9312 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9313 if (UNEXPECTED(EG(exception) != NULL)) {
9314 HANDLE_EXCEPTION();
9315 }
9316 zend_error_noreturn(E_ERROR, "Method name must be a string");
9317 }
9318
9319 function_name_strval = Z_STRVAL_P(function_name);
9320 function_name_strlen = Z_STRLEN_P(function_name);
9321
9322 call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9323
9324 if (EXPECTED(call->object != NULL) &&
9325 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
9326 call->called_scope = Z_OBJCE_P(call->object);
9327
9328 if (IS_CONST != IS_CONST ||
9329 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
9330 zval *object = call->object;
9331
9332 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
9333 zend_error_noreturn(E_ERROR, "Object does not support method calls");
9334 }
9335
9336 /* First, locate the function. */
9337 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
9338 if (UNEXPECTED(call->fbc == NULL)) {
9339 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
9340 }
9341 if (IS_CONST == IS_CONST &&
9342 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
9343 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
9344 EXPECTED(call->object == object)) {
9345 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
9346 }
9347 }
9348 } else {
9349 if (UNEXPECTED(EG(exception) != NULL)) {
9350
9351 HANDLE_EXCEPTION();
9352 }
9353 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
9354 }
9355
9356 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
9357 call->object = NULL;
9358 } else {
9359 if (!PZVAL_IS_REF(call->object)) {
9360 Z_ADDREF_P(call->object); /* For $this pointer */
9361 } else {
9362 zval *this_ptr;
9363 ALLOC_ZVAL(this_ptr);
9364 INIT_PZVAL_COPY(this_ptr, call->object);
9365 zval_copy_ctor(this_ptr);
9366 call->object = this_ptr;
9367 }
9368 }
9369
9370 call->num_additional_args = 0;
9371 call->is_ctor_call = 0;
9372 EX(call) = call;
9373
9374
9375 CHECK_EXCEPTION();
9376 ZEND_VM_NEXT_OPCODE();
9377 }
9378
ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9379 static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9380 {
9381 USE_OPLINE
9382 zend_free_op free_op1;
9383
9384 SAVE_OPLINE();
9385 is_equal_function(&EX_T(opline->result.var).tmp_var,
9386 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9387 opline->op2.zv TSRMLS_CC);
9388
9389 CHECK_EXCEPTION();
9390 ZEND_VM_NEXT_OPCODE();
9391 }
9392
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9393 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9394 {
9395 USE_OPLINE
9396 zend_free_op free_op1;
9397 zval *expr_ptr;
9398
9399 SAVE_OPLINE();
9400 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
9401 zval **expr_ptr_ptr = NULL;
9402
9403 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
9404 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
9405 }
9406 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
9407 expr_ptr = *expr_ptr_ptr;
9408 Z_ADDREF_P(expr_ptr);
9409 } else {
9410 expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9411 if (1) { /* temporary variable */
9412 zval *new_expr;
9413
9414 ALLOC_ZVAL(new_expr);
9415 INIT_PZVAL_COPY(new_expr, expr_ptr);
9416 expr_ptr = new_expr;
9417 } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
9418 zval *new_expr;
9419
9420 ALLOC_ZVAL(new_expr);
9421 INIT_PZVAL_COPY(new_expr, expr_ptr);
9422 expr_ptr = new_expr;
9423 zendi_zval_copy_ctor(*expr_ptr);
9424
9425 } else if (IS_TMP_VAR == IS_CV) {
9426 Z_ADDREF_P(expr_ptr);
9427 }
9428 }
9429
9430 if (IS_CONST != IS_UNUSED) {
9431
9432 zval *offset = opline->op2.zv;
9433 ulong hval;
9434
9435 switch (Z_TYPE_P(offset)) {
9436 case IS_DOUBLE:
9437 hval = zend_dval_to_lval(Z_DVAL_P(offset));
9438 goto num_index;
9439 case IS_LONG:
9440 case IS_BOOL:
9441 hval = Z_LVAL_P(offset);
9442 num_index:
9443 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
9444 break;
9445 case IS_STRING:
9446 if (IS_CONST == IS_CONST) {
9447 hval = Z_HASH_P(offset);
9448 } else {
9449 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
9450 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
9451 }
9452 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
9453 break;
9454 case IS_NULL:
9455 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
9456 break;
9457 default:
9458 zend_error(E_WARNING, "Illegal offset type");
9459 zval_ptr_dtor(&expr_ptr);
9460 /* do nothing */
9461 break;
9462 }
9463
9464 } else {
9465 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
9466 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
9467 zval_ptr_dtor(&expr_ptr);
9468 }
9469 }
9470 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
9471
9472 }
9473 CHECK_EXCEPTION();
9474 ZEND_VM_NEXT_OPCODE();
9475 }
9476
ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9477 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9478 {
9479 USE_OPLINE
9480
9481 array_init(&EX_T(opline->result.var).tmp_var);
9482 if (IS_TMP_VAR == IS_UNUSED) {
9483 ZEND_VM_NEXT_OPCODE();
9484 #if 0 || IS_TMP_VAR != IS_UNUSED
9485 } else {
9486 return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9487 #endif
9488 }
9489 }
9490
ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9491 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9492 {
9493 USE_OPLINE
9494 zval tmp, *varname;
9495 HashTable *target_symbol_table;
9496 zend_free_op free_op1;
9497
9498 SAVE_OPLINE();
9499 if (IS_TMP_VAR == IS_CV &&
9500 IS_CONST == IS_UNUSED &&
9501 (opline->extended_value & ZEND_QUICK_SET)) {
9502 if (EG(active_symbol_table)) {
9503 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
9504
9505 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
9506 EX_CV(opline->op1.var) = NULL;
9507 } else if (EX_CV(opline->op1.var)) {
9508 zval_ptr_dtor(EX_CV(opline->op1.var));
9509 EX_CV(opline->op1.var) = NULL;
9510 }
9511 CHECK_EXCEPTION();
9512 ZEND_VM_NEXT_OPCODE();
9513 }
9514
9515 varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9516
9517 if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
9518 ZVAL_COPY_VALUE(&tmp, varname);
9519 zval_copy_ctor(&tmp);
9520 convert_to_string(&tmp);
9521 varname = &tmp;
9522 } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
9523 Z_ADDREF_P(varname);
9524 }
9525
9526 if (IS_CONST != IS_UNUSED) {
9527 zend_class_entry *ce;
9528
9529 if (IS_CONST == IS_CONST) {
9530 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
9531 ce = CACHED_PTR(opline->op2.literal->cache_slot);
9532 } else {
9533 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
9534 if (UNEXPECTED(EG(exception) != NULL)) {
9535 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
9536 zval_dtor(&tmp);
9537 } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
9538 zval_ptr_dtor(&varname);
9539 }
9540 zval_dtor(free_op1.var);
9541 HANDLE_EXCEPTION();
9542 }
9543 if (UNEXPECTED(ce == NULL)) {
9544 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
9545 }
9546 CACHE_PTR(opline->op2.literal->cache_slot, ce);
9547 }
9548 } else {
9549 ce = EX_T(opline->op2.var).class_entry;
9550 }
9551 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
9552 } else {
9553 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
9554
9555 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
9556 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
9557 }
9558
9559 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
9560 zval_dtor(&tmp);
9561 } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
9562 zval_ptr_dtor(&varname);
9563 }
9564 zval_dtor(free_op1.var);
9565 CHECK_EXCEPTION();
9566 ZEND_VM_NEXT_OPCODE();
9567 }
9568
ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9569 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9570 {
9571 USE_OPLINE
9572 zval **value;
9573 zend_bool isset = 1;
9574
9575 SAVE_OPLINE();
9576 if (IS_TMP_VAR == IS_CV &&
9577 IS_CONST == IS_UNUSED &&
9578 (opline->extended_value & ZEND_QUICK_SET)) {
9579 if (EX_CV(opline->op1.var)) {
9580 value = EX_CV(opline->op1.var);
9581 } else if (EG(active_symbol_table)) {
9582 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
9583
9584 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
9585 isset = 0;
9586 }
9587 } else {
9588 isset = 0;
9589 }
9590 } else {
9591 HashTable *target_symbol_table;
9592 zend_free_op free_op1;
9593 zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9594
9595 if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
9596 ZVAL_COPY_VALUE(&tmp, varname);
9597 zval_copy_ctor(&tmp);
9598 convert_to_string(&tmp);
9599 varname = &tmp;
9600 }
9601
9602 if (IS_CONST != IS_UNUSED) {
9603 zend_class_entry *ce;
9604
9605 if (IS_CONST == IS_CONST) {
9606 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
9607 ce = CACHED_PTR(opline->op2.literal->cache_slot);
9608 } else {
9609 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
9610 if (UNEXPECTED(ce == NULL)) {
9611 CHECK_EXCEPTION();
9612 ZEND_VM_NEXT_OPCODE();
9613 }
9614 CACHE_PTR(opline->op2.literal->cache_slot, ce);
9615 }
9616 } else {
9617 ce = EX_T(opline->op2.var).class_entry;
9618 }
9619 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
9620 if (!value) {
9621 isset = 0;
9622 }
9623 } else {
9624 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
9625 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
9626 isset = 0;
9627 }
9628 }
9629
9630 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
9631 zval_dtor(&tmp);
9632 }
9633 zval_dtor(free_op1.var);
9634 }
9635
9636 if (opline->extended_value & ZEND_ISSET) {
9637 if (isset && Z_TYPE_PP(value) != IS_NULL) {
9638 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
9639 } else {
9640 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
9641 }
9642 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
9643 if (!isset || !i_zend_is_true(*value)) {
9644 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
9645 } else {
9646 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
9647 }
9648 }
9649
9650 CHECK_EXCEPTION();
9651 ZEND_VM_NEXT_OPCODE();
9652 }
9653
ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9654 static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9655 {
9656 USE_OPLINE
9657
9658 /* The generator object is stored in return_value_ptr_ptr */
9659 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
9660
9661 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
9662 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
9663 }
9664
9665 /* Destroy the previously yielded value */
9666 if (generator->value) {
9667 zval_ptr_dtor(&generator->value);
9668 }
9669
9670 /* Destroy the previously yielded key */
9671 if (generator->key) {
9672 zval_ptr_dtor(&generator->key);
9673 }
9674
9675 /* Set the new yielded value */
9676 if (IS_TMP_VAR != IS_UNUSED) {
9677 zend_free_op free_op1;
9678
9679 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
9680 /* Constants and temporary variables aren't yieldable by reference,
9681 * but we still allow them with a notice. */
9682 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
9683 zval *value, *copy;
9684
9685 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
9686
9687 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9688 ALLOC_ZVAL(copy);
9689 INIT_PZVAL_COPY(copy, value);
9690
9691 /* Temporary variables don't need ctor copying */
9692 if (!1) {
9693 zval_copy_ctor(copy);
9694 }
9695
9696 generator->value = copy;
9697 } else {
9698 zval **value_ptr = NULL;
9699
9700 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
9701 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
9702 }
9703
9704 /* If a function call result is yielded and the function did
9705 * not return by reference we throw a notice. */
9706 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
9707 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
9708 && EX_T(opline->op1.var).var.fcall_returned_reference)
9709 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
9710 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
9711
9712 Z_ADDREF_PP(value_ptr);
9713 generator->value = *value_ptr;
9714 } else {
9715 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
9716 Z_ADDREF_PP(value_ptr);
9717 generator->value = *value_ptr;
9718 }
9719
9720 }
9721 } else {
9722 zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9723
9724 /* Consts, temporary variables and references need copying */
9725 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
9726 || PZVAL_IS_REF(value)
9727 ) {
9728 zval *copy;
9729
9730 ALLOC_ZVAL(copy);
9731 INIT_PZVAL_COPY(copy, value);
9732
9733 /* Temporary variables don't need ctor copying */
9734 if (!1) {
9735 zval_copy_ctor(copy);
9736 }
9737
9738 generator->value = copy;
9739
9740 } else {
9741 if (IS_TMP_VAR == IS_CV) {
9742 Z_ADDREF_P(value);
9743 }
9744 generator->value = value;
9745 }
9746 }
9747 } else {
9748 /* If no value was specified yield null */
9749 Z_ADDREF(EG(uninitialized_zval));
9750 generator->value = &EG(uninitialized_zval);
9751 }
9752
9753 /* Set the new yielded key */
9754 if (IS_CONST != IS_UNUSED) {
9755
9756 zval *key = opline->op2.zv;
9757
9758 /* Consts, temporary variables and references need copying */
9759 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
9760 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
9761 ) {
9762 zval *copy;
9763
9764 ALLOC_ZVAL(copy);
9765 INIT_PZVAL_COPY(copy, key);
9766
9767 /* Temporary variables don't need ctor copying */
9768 if (!0) {
9769 zval_copy_ctor(copy);
9770 }
9771
9772 generator->key = copy;
9773 } else {
9774 Z_ADDREF_P(key);
9775 generator->key = key;
9776 }
9777
9778 if (Z_TYPE_P(generator->key) == IS_LONG
9779 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
9780 ) {
9781 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
9782 }
9783
9784 } else {
9785 /* If no key was specified we use auto-increment keys */
9786 generator->largest_used_integer_key++;
9787
9788 ALLOC_INIT_ZVAL(generator->key);
9789 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
9790 }
9791
9792 if (RETURN_VALUE_USED(opline)) {
9793 /* If the return value of yield is used set the send
9794 * target and initialize it to NULL */
9795 generator->send_target = &EX_T(opline->result.var).var.ptr;
9796 Z_ADDREF(EG(uninitialized_zval));
9797 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
9798 } else {
9799 generator->send_target = NULL;
9800 }
9801
9802 /* We increment to the next op, so we are at the correct position when the
9803 * generator is resumed. */
9804 ZEND_VM_INC_OPCODE();
9805
9806 /* The GOTO VM uses a local opline variable. We need to set the opline
9807 * variable in execute_data so we don't resume at an old position. */
9808 SAVE_OPLINE();
9809
9810 ZEND_VM_RETURN();
9811 }
9812
ZEND_POW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9813 static int ZEND_FASTCALL ZEND_POW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9814 {
9815 USE_OPLINE
9816 zend_free_op free_op1;
9817
9818 SAVE_OPLINE();
9819 pow_function(&EX_T(opline->result.var).tmp_var,
9820 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9821 opline->op2.zv TSRMLS_CC);
9822 zval_dtor(free_op1.var);
9823
9824 CHECK_EXCEPTION();
9825 ZEND_VM_NEXT_OPCODE();
9826 }
9827
ZEND_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9828 static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9829 {
9830 USE_OPLINE
9831 zend_free_op free_op1, free_op2;
9832
9833 SAVE_OPLINE();
9834 fast_add_function(&EX_T(opline->result.var).tmp_var,
9835 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9836 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9837 zval_dtor(free_op1.var);
9838 zval_dtor(free_op2.var);
9839 CHECK_EXCEPTION();
9840 ZEND_VM_NEXT_OPCODE();
9841 }
9842
ZEND_SUB_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9843 static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9844 {
9845 USE_OPLINE
9846 zend_free_op free_op1, free_op2;
9847
9848 SAVE_OPLINE();
9849 fast_sub_function(&EX_T(opline->result.var).tmp_var,
9850 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9851 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9852 zval_dtor(free_op1.var);
9853 zval_dtor(free_op2.var);
9854 CHECK_EXCEPTION();
9855 ZEND_VM_NEXT_OPCODE();
9856 }
9857
ZEND_MUL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9858 static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9859 {
9860 USE_OPLINE
9861 zend_free_op free_op1, free_op2;
9862
9863 SAVE_OPLINE();
9864 fast_mul_function(&EX_T(opline->result.var).tmp_var,
9865 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9866 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9867 zval_dtor(free_op1.var);
9868 zval_dtor(free_op2.var);
9869 CHECK_EXCEPTION();
9870 ZEND_VM_NEXT_OPCODE();
9871 }
9872
ZEND_DIV_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9873 static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9874 {
9875 USE_OPLINE
9876 zend_free_op free_op1, free_op2;
9877
9878 SAVE_OPLINE();
9879 fast_div_function(&EX_T(opline->result.var).tmp_var,
9880 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9881 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9882 zval_dtor(free_op1.var);
9883 zval_dtor(free_op2.var);
9884 CHECK_EXCEPTION();
9885 ZEND_VM_NEXT_OPCODE();
9886 }
9887
ZEND_MOD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9888 static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9889 {
9890 USE_OPLINE
9891 zend_free_op free_op1, free_op2;
9892
9893 SAVE_OPLINE();
9894 fast_mod_function(&EX_T(opline->result.var).tmp_var,
9895 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9896 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9897 zval_dtor(free_op1.var);
9898 zval_dtor(free_op2.var);
9899 CHECK_EXCEPTION();
9900 ZEND_VM_NEXT_OPCODE();
9901 }
9902
ZEND_SL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9903 static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9904 {
9905 USE_OPLINE
9906 zend_free_op free_op1, free_op2;
9907
9908 SAVE_OPLINE();
9909 shift_left_function(&EX_T(opline->result.var).tmp_var,
9910 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9911 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9912 zval_dtor(free_op1.var);
9913 zval_dtor(free_op2.var);
9914 CHECK_EXCEPTION();
9915 ZEND_VM_NEXT_OPCODE();
9916 }
9917
ZEND_SR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9918 static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9919 {
9920 USE_OPLINE
9921 zend_free_op free_op1, free_op2;
9922
9923 SAVE_OPLINE();
9924 shift_right_function(&EX_T(opline->result.var).tmp_var,
9925 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9926 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9927 zval_dtor(free_op1.var);
9928 zval_dtor(free_op2.var);
9929 CHECK_EXCEPTION();
9930 ZEND_VM_NEXT_OPCODE();
9931 }
9932
ZEND_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9933 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9934 {
9935 USE_OPLINE
9936 zend_free_op free_op1, free_op2;
9937
9938 SAVE_OPLINE();
9939 concat_function(&EX_T(opline->result.var).tmp_var,
9940 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9941 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9942 zval_dtor(free_op1.var);
9943 zval_dtor(free_op2.var);
9944 CHECK_EXCEPTION();
9945 ZEND_VM_NEXT_OPCODE();
9946 }
9947
ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9948 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9949 {
9950 USE_OPLINE
9951 zend_free_op free_op1, free_op2;
9952
9953 SAVE_OPLINE();
9954 is_identical_function(&EX_T(opline->result.var).tmp_var,
9955 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9956 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9957 zval_dtor(free_op1.var);
9958 zval_dtor(free_op2.var);
9959 CHECK_EXCEPTION();
9960 ZEND_VM_NEXT_OPCODE();
9961 }
9962
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9963 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9964 {
9965 USE_OPLINE
9966 zend_free_op free_op1, free_op2;
9967 zval *result = &EX_T(opline->result.var).tmp_var;
9968
9969 SAVE_OPLINE();
9970 is_identical_function(result,
9971 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9972 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9973 Z_LVAL_P(result) = !Z_LVAL_P(result);
9974 zval_dtor(free_op1.var);
9975 zval_dtor(free_op2.var);
9976 CHECK_EXCEPTION();
9977 ZEND_VM_NEXT_OPCODE();
9978 }
9979
ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9980 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9981 {
9982 USE_OPLINE
9983 zend_free_op free_op1, free_op2;
9984 zval *result = &EX_T(opline->result.var).tmp_var;
9985
9986 SAVE_OPLINE();
9987 ZVAL_BOOL(result, fast_equal_function(result,
9988 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9989 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
9990 zval_dtor(free_op1.var);
9991 zval_dtor(free_op2.var);
9992 CHECK_EXCEPTION();
9993 ZEND_VM_NEXT_OPCODE();
9994 }
9995
ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9996 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9997 {
9998 USE_OPLINE
9999 zend_free_op free_op1, free_op2;
10000 zval *result = &EX_T(opline->result.var).tmp_var;
10001
10002 SAVE_OPLINE();
10003 ZVAL_BOOL(result, fast_not_equal_function(result,
10004 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10005 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10006 zval_dtor(free_op1.var);
10007 zval_dtor(free_op2.var);
10008 CHECK_EXCEPTION();
10009 ZEND_VM_NEXT_OPCODE();
10010 }
10011
ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10012 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10013 {
10014 USE_OPLINE
10015 zend_free_op free_op1, free_op2;
10016 zval *result = &EX_T(opline->result.var).tmp_var;
10017
10018 SAVE_OPLINE();
10019 ZVAL_BOOL(result, fast_is_smaller_function(result,
10020 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10021 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10022 zval_dtor(free_op1.var);
10023 zval_dtor(free_op2.var);
10024 CHECK_EXCEPTION();
10025 ZEND_VM_NEXT_OPCODE();
10026 }
10027
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10028 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10029 {
10030 USE_OPLINE
10031 zend_free_op free_op1, free_op2;
10032 zval *result = &EX_T(opline->result.var).tmp_var;
10033
10034 SAVE_OPLINE();
10035 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
10036 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10037 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10038 zval_dtor(free_op1.var);
10039 zval_dtor(free_op2.var);
10040 CHECK_EXCEPTION();
10041 ZEND_VM_NEXT_OPCODE();
10042 }
10043
ZEND_BW_OR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10044 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10045 {
10046 USE_OPLINE
10047 zend_free_op free_op1, free_op2;
10048
10049 SAVE_OPLINE();
10050 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
10051 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10052 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10053 zval_dtor(free_op1.var);
10054 zval_dtor(free_op2.var);
10055 CHECK_EXCEPTION();
10056 ZEND_VM_NEXT_OPCODE();
10057 }
10058
ZEND_BW_AND_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10059 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10060 {
10061 USE_OPLINE
10062 zend_free_op free_op1, free_op2;
10063
10064 SAVE_OPLINE();
10065 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
10066 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10067 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10068 zval_dtor(free_op1.var);
10069 zval_dtor(free_op2.var);
10070 CHECK_EXCEPTION();
10071 ZEND_VM_NEXT_OPCODE();
10072 }
10073
ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10074 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10075 {
10076 USE_OPLINE
10077 zend_free_op free_op1, free_op2;
10078
10079 SAVE_OPLINE();
10080 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
10081 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10082 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10083 zval_dtor(free_op1.var);
10084 zval_dtor(free_op2.var);
10085 CHECK_EXCEPTION();
10086 ZEND_VM_NEXT_OPCODE();
10087 }
10088
ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10089 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10090 {
10091 USE_OPLINE
10092 zend_free_op free_op1, free_op2;
10093
10094 SAVE_OPLINE();
10095 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
10096 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10097 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10098 zval_dtor(free_op1.var);
10099 zval_dtor(free_op2.var);
10100 CHECK_EXCEPTION();
10101 ZEND_VM_NEXT_OPCODE();
10102 }
10103
ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10104 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10105 {
10106 USE_OPLINE
10107 zend_free_op free_op1, free_op2;
10108 zval *container;
10109
10110 SAVE_OPLINE();
10111 container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10112 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
10113 zval_dtor(free_op2.var);
10114 if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
10115 zval_dtor(free_op1.var);
10116 }
10117 CHECK_EXCEPTION();
10118 ZEND_VM_NEXT_OPCODE();
10119 }
10120
ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10121 static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10122 {
10123 USE_OPLINE
10124 zend_free_op free_op2;
10125 zval *str = &EX_T(opline->result.var).tmp_var;
10126 zval *var;
10127 zval var_copy;
10128 int use_copy = 0;
10129
10130 SAVE_OPLINE();
10131 var = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
10132
10133 if (IS_TMP_VAR == IS_UNUSED) {
10134 /* Initialize for erealloc in add_string_to_string */
10135 Z_STRVAL_P(str) = NULL;
10136 Z_STRLEN_P(str) = 0;
10137 Z_TYPE_P(str) = IS_STRING;
10138
10139 INIT_PZVAL(str);
10140 }
10141
10142 if (Z_TYPE_P(var) != IS_STRING) {
10143 zend_make_printable_zval(var, &var_copy, &use_copy);
10144
10145 if (use_copy) {
10146 var = &var_copy;
10147 }
10148 }
10149 add_string_to_string(str, str, var);
10150
10151 if (use_copy) {
10152 zval_dtor(var);
10153 }
10154 /* original comment, possibly problematic:
10155 * FREE_OP is missing intentionally here - we're always working on the same temporary variable
10156 * (Zeev): I don't think it's problematic, we only use variables
10157 * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
10158 * string offsets or overloaded objects
10159 */
10160 zval_dtor(free_op2.var);
10161
10162 CHECK_EXCEPTION();
10163 ZEND_VM_NEXT_OPCODE();
10164 }
10165
ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10166 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10167 {
10168 USE_OPLINE
10169 zval *function_name;
10170 char *function_name_strval;
10171 int function_name_strlen;
10172 zend_free_op free_op1, free_op2;
10173 call_slot *call = EX(call_slots) + opline->result.num;
10174
10175 SAVE_OPLINE();
10176
10177 function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
10178
10179 if (IS_TMP_VAR != IS_CONST &&
10180 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
10181 if (UNEXPECTED(EG(exception) != NULL)) {
10182 HANDLE_EXCEPTION();
10183 }
10184 zend_error_noreturn(E_ERROR, "Method name must be a string");
10185 }
10186
10187 function_name_strval = Z_STRVAL_P(function_name);
10188 function_name_strlen = Z_STRLEN_P(function_name);
10189
10190 call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10191
10192 if (EXPECTED(call->object != NULL) &&
10193 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
10194 call->called_scope = Z_OBJCE_P(call->object);
10195
10196 if (IS_TMP_VAR != IS_CONST ||
10197 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
10198 zval *object = call->object;
10199
10200 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
10201 zend_error_noreturn(E_ERROR, "Object does not support method calls");
10202 }
10203
10204 /* First, locate the function. */
10205 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
10206 if (UNEXPECTED(call->fbc == NULL)) {
10207 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
10208 }
10209 if (IS_TMP_VAR == IS_CONST &&
10210 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
10211 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
10212 EXPECTED(call->object == object)) {
10213 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
10214 }
10215 }
10216 } else {
10217 if (UNEXPECTED(EG(exception) != NULL)) {
10218 zval_dtor(free_op2.var);
10219 HANDLE_EXCEPTION();
10220 }
10221 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
10222 }
10223
10224 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
10225 call->object = NULL;
10226 } else {
10227 if (!PZVAL_IS_REF(call->object)) {
10228 Z_ADDREF_P(call->object); /* For $this pointer */
10229 } else {
10230 zval *this_ptr;
10231 ALLOC_ZVAL(this_ptr);
10232 INIT_PZVAL_COPY(this_ptr, call->object);
10233 zval_copy_ctor(this_ptr);
10234 call->object = this_ptr;
10235 }
10236 }
10237
10238 call->num_additional_args = 0;
10239 call->is_ctor_call = 0;
10240 EX(call) = call;
10241
10242 zval_dtor(free_op2.var);
10243
10244 CHECK_EXCEPTION();
10245 ZEND_VM_NEXT_OPCODE();
10246 }
10247
ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10248 static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10249 {
10250 USE_OPLINE
10251 zend_free_op free_op1, free_op2;
10252
10253 SAVE_OPLINE();
10254 is_equal_function(&EX_T(opline->result.var).tmp_var,
10255 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10256 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10257
10258 zval_dtor(free_op2.var);
10259 CHECK_EXCEPTION();
10260 ZEND_VM_NEXT_OPCODE();
10261 }
10262
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10263 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10264 {
10265 USE_OPLINE
10266 zend_free_op free_op1;
10267 zval *expr_ptr;
10268
10269 SAVE_OPLINE();
10270 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
10271 zval **expr_ptr_ptr = NULL;
10272
10273 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
10274 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
10275 }
10276 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
10277 expr_ptr = *expr_ptr_ptr;
10278 Z_ADDREF_P(expr_ptr);
10279 } else {
10280 expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10281 if (1) { /* temporary variable */
10282 zval *new_expr;
10283
10284 ALLOC_ZVAL(new_expr);
10285 INIT_PZVAL_COPY(new_expr, expr_ptr);
10286 expr_ptr = new_expr;
10287 } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
10288 zval *new_expr;
10289
10290 ALLOC_ZVAL(new_expr);
10291 INIT_PZVAL_COPY(new_expr, expr_ptr);
10292 expr_ptr = new_expr;
10293 zendi_zval_copy_ctor(*expr_ptr);
10294
10295 } else if (IS_TMP_VAR == IS_CV) {
10296 Z_ADDREF_P(expr_ptr);
10297 }
10298 }
10299
10300 if (IS_TMP_VAR != IS_UNUSED) {
10301 zend_free_op free_op2;
10302 zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
10303 ulong hval;
10304
10305 switch (Z_TYPE_P(offset)) {
10306 case IS_DOUBLE:
10307 hval = zend_dval_to_lval(Z_DVAL_P(offset));
10308 goto num_index;
10309 case IS_LONG:
10310 case IS_BOOL:
10311 hval = Z_LVAL_P(offset);
10312 num_index:
10313 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
10314 break;
10315 case IS_STRING:
10316 if (IS_TMP_VAR == IS_CONST) {
10317 hval = Z_HASH_P(offset);
10318 } else {
10319 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
10320 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
10321 }
10322 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
10323 break;
10324 case IS_NULL:
10325 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
10326 break;
10327 default:
10328 zend_error(E_WARNING, "Illegal offset type");
10329 zval_ptr_dtor(&expr_ptr);
10330 /* do nothing */
10331 break;
10332 }
10333 zval_dtor(free_op2.var);
10334 } else {
10335 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
10336 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
10337 zval_ptr_dtor(&expr_ptr);
10338 }
10339 }
10340 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
10341
10342 }
10343 CHECK_EXCEPTION();
10344 ZEND_VM_NEXT_OPCODE();
10345 }
10346
ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10347 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10348 {
10349 USE_OPLINE
10350
10351 array_init(&EX_T(opline->result.var).tmp_var);
10352 if (IS_TMP_VAR == IS_UNUSED) {
10353 ZEND_VM_NEXT_OPCODE();
10354 #if 0 || IS_TMP_VAR != IS_UNUSED
10355 } else {
10356 return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10357 #endif
10358 }
10359 }
10360
ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10361 static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10362 {
10363 USE_OPLINE
10364
10365 /* The generator object is stored in return_value_ptr_ptr */
10366 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
10367
10368 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
10369 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
10370 }
10371
10372 /* Destroy the previously yielded value */
10373 if (generator->value) {
10374 zval_ptr_dtor(&generator->value);
10375 }
10376
10377 /* Destroy the previously yielded key */
10378 if (generator->key) {
10379 zval_ptr_dtor(&generator->key);
10380 }
10381
10382 /* Set the new yielded value */
10383 if (IS_TMP_VAR != IS_UNUSED) {
10384 zend_free_op free_op1;
10385
10386 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
10387 /* Constants and temporary variables aren't yieldable by reference,
10388 * but we still allow them with a notice. */
10389 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
10390 zval *value, *copy;
10391
10392 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10393
10394 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10395 ALLOC_ZVAL(copy);
10396 INIT_PZVAL_COPY(copy, value);
10397
10398 /* Temporary variables don't need ctor copying */
10399 if (!1) {
10400 zval_copy_ctor(copy);
10401 }
10402
10403 generator->value = copy;
10404 } else {
10405 zval **value_ptr = NULL;
10406
10407 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
10408 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
10409 }
10410
10411 /* If a function call result is yielded and the function did
10412 * not return by reference we throw a notice. */
10413 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
10414 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
10415 && EX_T(opline->op1.var).var.fcall_returned_reference)
10416 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
10417 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10418
10419 Z_ADDREF_PP(value_ptr);
10420 generator->value = *value_ptr;
10421 } else {
10422 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
10423 Z_ADDREF_PP(value_ptr);
10424 generator->value = *value_ptr;
10425 }
10426
10427 }
10428 } else {
10429 zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10430
10431 /* Consts, temporary variables and references need copying */
10432 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
10433 || PZVAL_IS_REF(value)
10434 ) {
10435 zval *copy;
10436
10437 ALLOC_ZVAL(copy);
10438 INIT_PZVAL_COPY(copy, value);
10439
10440 /* Temporary variables don't need ctor copying */
10441 if (!1) {
10442 zval_copy_ctor(copy);
10443 }
10444
10445 generator->value = copy;
10446
10447 } else {
10448 if (IS_TMP_VAR == IS_CV) {
10449 Z_ADDREF_P(value);
10450 }
10451 generator->value = value;
10452 }
10453 }
10454 } else {
10455 /* If no value was specified yield null */
10456 Z_ADDREF(EG(uninitialized_zval));
10457 generator->value = &EG(uninitialized_zval);
10458 }
10459
10460 /* Set the new yielded key */
10461 if (IS_TMP_VAR != IS_UNUSED) {
10462 zend_free_op free_op2;
10463 zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
10464
10465 /* Consts, temporary variables and references need copying */
10466 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
10467 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
10468 ) {
10469 zval *copy;
10470
10471 ALLOC_ZVAL(copy);
10472 INIT_PZVAL_COPY(copy, key);
10473
10474 /* Temporary variables don't need ctor copying */
10475 if (!1) {
10476 zval_copy_ctor(copy);
10477 }
10478
10479 generator->key = copy;
10480 } else {
10481 Z_ADDREF_P(key);
10482 generator->key = key;
10483 }
10484
10485 if (Z_TYPE_P(generator->key) == IS_LONG
10486 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
10487 ) {
10488 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
10489 }
10490
10491 } else {
10492 /* If no key was specified we use auto-increment keys */
10493 generator->largest_used_integer_key++;
10494
10495 ALLOC_INIT_ZVAL(generator->key);
10496 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
10497 }
10498
10499 if (RETURN_VALUE_USED(opline)) {
10500 /* If the return value of yield is used set the send
10501 * target and initialize it to NULL */
10502 generator->send_target = &EX_T(opline->result.var).var.ptr;
10503 Z_ADDREF(EG(uninitialized_zval));
10504 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
10505 } else {
10506 generator->send_target = NULL;
10507 }
10508
10509 /* We increment to the next op, so we are at the correct position when the
10510 * generator is resumed. */
10511 ZEND_VM_INC_OPCODE();
10512
10513 /* The GOTO VM uses a local opline variable. We need to set the opline
10514 * variable in execute_data so we don't resume at an old position. */
10515 SAVE_OPLINE();
10516
10517 ZEND_VM_RETURN();
10518 }
10519
ZEND_POW_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10520 static int ZEND_FASTCALL ZEND_POW_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10521 {
10522 USE_OPLINE
10523 zend_free_op free_op1, free_op2;
10524
10525 SAVE_OPLINE();
10526 pow_function(&EX_T(opline->result.var).tmp_var,
10527 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10528 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10529 zval_dtor(free_op1.var);
10530 zval_dtor(free_op2.var);
10531 CHECK_EXCEPTION();
10532 ZEND_VM_NEXT_OPCODE();
10533 }
10534
ZEND_ADD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10535 static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10536 {
10537 USE_OPLINE
10538 zend_free_op free_op1, free_op2;
10539
10540 SAVE_OPLINE();
10541 fast_add_function(&EX_T(opline->result.var).tmp_var,
10542 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10543 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10544 zval_dtor(free_op1.var);
10545 zval_ptr_dtor_nogc(&free_op2.var);
10546 CHECK_EXCEPTION();
10547 ZEND_VM_NEXT_OPCODE();
10548 }
10549
ZEND_SUB_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10550 static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10551 {
10552 USE_OPLINE
10553 zend_free_op free_op1, free_op2;
10554
10555 SAVE_OPLINE();
10556 fast_sub_function(&EX_T(opline->result.var).tmp_var,
10557 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10558 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10559 zval_dtor(free_op1.var);
10560 zval_ptr_dtor_nogc(&free_op2.var);
10561 CHECK_EXCEPTION();
10562 ZEND_VM_NEXT_OPCODE();
10563 }
10564
ZEND_MUL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10565 static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10566 {
10567 USE_OPLINE
10568 zend_free_op free_op1, free_op2;
10569
10570 SAVE_OPLINE();
10571 fast_mul_function(&EX_T(opline->result.var).tmp_var,
10572 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10573 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10574 zval_dtor(free_op1.var);
10575 zval_ptr_dtor_nogc(&free_op2.var);
10576 CHECK_EXCEPTION();
10577 ZEND_VM_NEXT_OPCODE();
10578 }
10579
ZEND_DIV_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10580 static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10581 {
10582 USE_OPLINE
10583 zend_free_op free_op1, free_op2;
10584
10585 SAVE_OPLINE();
10586 fast_div_function(&EX_T(opline->result.var).tmp_var,
10587 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10588 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10589 zval_dtor(free_op1.var);
10590 zval_ptr_dtor_nogc(&free_op2.var);
10591 CHECK_EXCEPTION();
10592 ZEND_VM_NEXT_OPCODE();
10593 }
10594
ZEND_MOD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10595 static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10596 {
10597 USE_OPLINE
10598 zend_free_op free_op1, free_op2;
10599
10600 SAVE_OPLINE();
10601 fast_mod_function(&EX_T(opline->result.var).tmp_var,
10602 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10603 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10604 zval_dtor(free_op1.var);
10605 zval_ptr_dtor_nogc(&free_op2.var);
10606 CHECK_EXCEPTION();
10607 ZEND_VM_NEXT_OPCODE();
10608 }
10609
ZEND_SL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10610 static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10611 {
10612 USE_OPLINE
10613 zend_free_op free_op1, free_op2;
10614
10615 SAVE_OPLINE();
10616 shift_left_function(&EX_T(opline->result.var).tmp_var,
10617 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10618 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10619 zval_dtor(free_op1.var);
10620 zval_ptr_dtor_nogc(&free_op2.var);
10621 CHECK_EXCEPTION();
10622 ZEND_VM_NEXT_OPCODE();
10623 }
10624
ZEND_SR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10625 static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10626 {
10627 USE_OPLINE
10628 zend_free_op free_op1, free_op2;
10629
10630 SAVE_OPLINE();
10631 shift_right_function(&EX_T(opline->result.var).tmp_var,
10632 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10633 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10634 zval_dtor(free_op1.var);
10635 zval_ptr_dtor_nogc(&free_op2.var);
10636 CHECK_EXCEPTION();
10637 ZEND_VM_NEXT_OPCODE();
10638 }
10639
ZEND_CONCAT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10640 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10641 {
10642 USE_OPLINE
10643 zend_free_op free_op1, free_op2;
10644
10645 SAVE_OPLINE();
10646 concat_function(&EX_T(opline->result.var).tmp_var,
10647 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10648 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10649 zval_dtor(free_op1.var);
10650 zval_ptr_dtor_nogc(&free_op2.var);
10651 CHECK_EXCEPTION();
10652 ZEND_VM_NEXT_OPCODE();
10653 }
10654
ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10655 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10656 {
10657 USE_OPLINE
10658 zend_free_op free_op1, free_op2;
10659
10660 SAVE_OPLINE();
10661 is_identical_function(&EX_T(opline->result.var).tmp_var,
10662 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10663 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10664 zval_dtor(free_op1.var);
10665 zval_ptr_dtor_nogc(&free_op2.var);
10666 CHECK_EXCEPTION();
10667 ZEND_VM_NEXT_OPCODE();
10668 }
10669
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10670 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10671 {
10672 USE_OPLINE
10673 zend_free_op free_op1, free_op2;
10674 zval *result = &EX_T(opline->result.var).tmp_var;
10675
10676 SAVE_OPLINE();
10677 is_identical_function(result,
10678 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10679 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10680 Z_LVAL_P(result) = !Z_LVAL_P(result);
10681 zval_dtor(free_op1.var);
10682 zval_ptr_dtor_nogc(&free_op2.var);
10683 CHECK_EXCEPTION();
10684 ZEND_VM_NEXT_OPCODE();
10685 }
10686
ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10687 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10688 {
10689 USE_OPLINE
10690 zend_free_op free_op1, free_op2;
10691 zval *result = &EX_T(opline->result.var).tmp_var;
10692
10693 SAVE_OPLINE();
10694 ZVAL_BOOL(result, fast_equal_function(result,
10695 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10696 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10697 zval_dtor(free_op1.var);
10698 zval_ptr_dtor_nogc(&free_op2.var);
10699 CHECK_EXCEPTION();
10700 ZEND_VM_NEXT_OPCODE();
10701 }
10702
ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10703 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10704 {
10705 USE_OPLINE
10706 zend_free_op free_op1, free_op2;
10707 zval *result = &EX_T(opline->result.var).tmp_var;
10708
10709 SAVE_OPLINE();
10710 ZVAL_BOOL(result, fast_not_equal_function(result,
10711 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10712 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10713 zval_dtor(free_op1.var);
10714 zval_ptr_dtor_nogc(&free_op2.var);
10715 CHECK_EXCEPTION();
10716 ZEND_VM_NEXT_OPCODE();
10717 }
10718
ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10719 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10720 {
10721 USE_OPLINE
10722 zend_free_op free_op1, free_op2;
10723 zval *result = &EX_T(opline->result.var).tmp_var;
10724
10725 SAVE_OPLINE();
10726 ZVAL_BOOL(result, fast_is_smaller_function(result,
10727 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10728 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10729 zval_dtor(free_op1.var);
10730 zval_ptr_dtor_nogc(&free_op2.var);
10731 CHECK_EXCEPTION();
10732 ZEND_VM_NEXT_OPCODE();
10733 }
10734
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10735 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10736 {
10737 USE_OPLINE
10738 zend_free_op free_op1, free_op2;
10739 zval *result = &EX_T(opline->result.var).tmp_var;
10740
10741 SAVE_OPLINE();
10742 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
10743 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10744 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10745 zval_dtor(free_op1.var);
10746 zval_ptr_dtor_nogc(&free_op2.var);
10747 CHECK_EXCEPTION();
10748 ZEND_VM_NEXT_OPCODE();
10749 }
10750
ZEND_BW_OR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10751 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10752 {
10753 USE_OPLINE
10754 zend_free_op free_op1, free_op2;
10755
10756 SAVE_OPLINE();
10757 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
10758 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10759 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10760 zval_dtor(free_op1.var);
10761 zval_ptr_dtor_nogc(&free_op2.var);
10762 CHECK_EXCEPTION();
10763 ZEND_VM_NEXT_OPCODE();
10764 }
10765
ZEND_BW_AND_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10766 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10767 {
10768 USE_OPLINE
10769 zend_free_op free_op1, free_op2;
10770
10771 SAVE_OPLINE();
10772 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
10773 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10774 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10775 zval_dtor(free_op1.var);
10776 zval_ptr_dtor_nogc(&free_op2.var);
10777 CHECK_EXCEPTION();
10778 ZEND_VM_NEXT_OPCODE();
10779 }
10780
ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10781 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10782 {
10783 USE_OPLINE
10784 zend_free_op free_op1, free_op2;
10785
10786 SAVE_OPLINE();
10787 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
10788 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10789 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10790 zval_dtor(free_op1.var);
10791 zval_ptr_dtor_nogc(&free_op2.var);
10792 CHECK_EXCEPTION();
10793 ZEND_VM_NEXT_OPCODE();
10794 }
10795
ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10796 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10797 {
10798 USE_OPLINE
10799 zend_free_op free_op1, free_op2;
10800
10801 SAVE_OPLINE();
10802 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
10803 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10804 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10805 zval_dtor(free_op1.var);
10806 zval_ptr_dtor_nogc(&free_op2.var);
10807 CHECK_EXCEPTION();
10808 ZEND_VM_NEXT_OPCODE();
10809 }
10810
zend_fetch_var_address_helper_SPEC_TMP_VAR(int type,ZEND_OPCODE_HANDLER_ARGS)10811 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
10812 {
10813 USE_OPLINE
10814 zend_free_op free_op1;
10815 zval *varname;
10816 zval **retval;
10817 zval tmp_varname;
10818 HashTable *target_symbol_table;
10819 ulong hash_value;
10820
10821 SAVE_OPLINE();
10822 varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10823
10824 if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
10825 ZVAL_COPY_VALUE(&tmp_varname, varname);
10826 zval_copy_ctor(&tmp_varname);
10827 Z_SET_REFCOUNT(tmp_varname, 1);
10828 Z_UNSET_ISREF(tmp_varname);
10829 convert_to_string(&tmp_varname);
10830 varname = &tmp_varname;
10831 }
10832
10833 if (IS_VAR != IS_UNUSED) {
10834 zend_class_entry *ce;
10835
10836 if (IS_VAR == IS_CONST) {
10837 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
10838 ce = CACHED_PTR(opline->op2.literal->cache_slot);
10839 } else {
10840 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
10841 if (UNEXPECTED(ce == NULL)) {
10842 if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
10843 zval_dtor(&tmp_varname);
10844 }
10845 zval_dtor(free_op1.var);
10846 CHECK_EXCEPTION();
10847 ZEND_VM_NEXT_OPCODE();
10848 }
10849 CACHE_PTR(opline->op2.literal->cache_slot, ce);
10850 }
10851 } else {
10852 ce = EX_T(opline->op2.var).class_entry;
10853 }
10854 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
10855 zval_dtor(free_op1.var);
10856 } else {
10857 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
10858 /*
10859 if (!target_symbol_table) {
10860 CHECK_EXCEPTION();
10861 ZEND_VM_NEXT_OPCODE();
10862 }
10863 */
10864 if (IS_TMP_VAR == IS_CONST) {
10865 hash_value = Z_HASH_P(varname);
10866 } else {
10867 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
10868 }
10869
10870 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
10871 switch (type) {
10872 case BP_VAR_R:
10873 case BP_VAR_UNSET:
10874 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
10875 /* break missing intentionally */
10876 case BP_VAR_IS:
10877 retval = &EG(uninitialized_zval_ptr);
10878 break;
10879 case BP_VAR_RW:
10880 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
10881 /* break missing intentionally */
10882 case BP_VAR_W:
10883 Z_ADDREF_P(&EG(uninitialized_zval));
10884 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
10885 break;
10886 EMPTY_SWITCH_DEFAULT_CASE()
10887 }
10888 }
10889 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
10890 case ZEND_FETCH_GLOBAL:
10891 if (IS_TMP_VAR != IS_TMP_VAR) {
10892 zval_dtor(free_op1.var);
10893 }
10894 break;
10895 case ZEND_FETCH_LOCAL:
10896 zval_dtor(free_op1.var);
10897 break;
10898 case ZEND_FETCH_STATIC:
10899 zval_update_constant(retval, 1 TSRMLS_CC);
10900 break;
10901 case ZEND_FETCH_GLOBAL_LOCK:
10902 if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
10903 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
10904 }
10905 break;
10906 }
10907 }
10908
10909
10910 if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
10911 zval_dtor(&tmp_varname);
10912 }
10913 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
10914 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
10915 }
10916 PZVAL_LOCK(*retval);
10917 switch (type) {
10918 case BP_VAR_R:
10919 case BP_VAR_IS:
10920 EX_T(opline->result.var).var.ptr = *retval;
10921 break;
10922 case BP_VAR_UNSET: {
10923 zend_free_op free_res;
10924
10925 PZVAL_UNLOCK(*retval, &free_res);
10926 if (retval != &EG(uninitialized_zval_ptr)) {
10927 SEPARATE_ZVAL_IF_NOT_REF(retval);
10928 }
10929 PZVAL_LOCK(*retval);
10930 FREE_OP_VAR_PTR(free_res);
10931 }
10932 /* break missing intentionally */
10933 default:
10934 EX_T(opline->result.var).var.ptr_ptr = retval;
10935 break;
10936 }
10937 CHECK_EXCEPTION();
10938 ZEND_VM_NEXT_OPCODE();
10939 }
10940
ZEND_FETCH_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10941 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10942 {
10943 return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10944 }
10945
ZEND_FETCH_W_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10946 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10947 {
10948 return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10949 }
10950
ZEND_FETCH_RW_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10951 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10952 {
10953 return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10954 }
10955
ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10956 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10957 {
10958 USE_OPLINE
10959
10960 return zend_fetch_var_address_helper_SPEC_TMP_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10961 }
10962
ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10963 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10964 {
10965 return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10966 }
10967
ZEND_FETCH_IS_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10968 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10969 {
10970 return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10971 }
10972
ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10973 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10974 {
10975 USE_OPLINE
10976 zend_free_op free_op1, free_op2;
10977 zval *container;
10978
10979 SAVE_OPLINE();
10980 container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10981 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
10982 zval_ptr_dtor_nogc(&free_op2.var);
10983 if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
10984 zval_dtor(free_op1.var);
10985 }
10986 CHECK_EXCEPTION();
10987 ZEND_VM_NEXT_OPCODE();
10988 }
10989
ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10990 static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10991 {
10992 USE_OPLINE
10993 zend_free_op free_op2;
10994 zval *str = &EX_T(opline->result.var).tmp_var;
10995 zval *var;
10996 zval var_copy;
10997 int use_copy = 0;
10998
10999 SAVE_OPLINE();
11000 var = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
11001
11002 if (IS_TMP_VAR == IS_UNUSED) {
11003 /* Initialize for erealloc in add_string_to_string */
11004 Z_STRVAL_P(str) = NULL;
11005 Z_STRLEN_P(str) = 0;
11006 Z_TYPE_P(str) = IS_STRING;
11007
11008 INIT_PZVAL(str);
11009 }
11010
11011 if (Z_TYPE_P(var) != IS_STRING) {
11012 zend_make_printable_zval(var, &var_copy, &use_copy);
11013
11014 if (use_copy) {
11015 var = &var_copy;
11016 }
11017 }
11018 add_string_to_string(str, str, var);
11019
11020 if (use_copy) {
11021 zval_dtor(var);
11022 }
11023 /* original comment, possibly problematic:
11024 * FREE_OP is missing intentionally here - we're always working on the same temporary variable
11025 * (Zeev): I don't think it's problematic, we only use variables
11026 * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
11027 * string offsets or overloaded objects
11028 */
11029 zval_ptr_dtor_nogc(&free_op2.var);
11030
11031 CHECK_EXCEPTION();
11032 ZEND_VM_NEXT_OPCODE();
11033 }
11034
ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11035 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11036 {
11037 USE_OPLINE
11038 zval *function_name;
11039 char *function_name_strval;
11040 int function_name_strlen;
11041 zend_free_op free_op1, free_op2;
11042 call_slot *call = EX(call_slots) + opline->result.num;
11043
11044 SAVE_OPLINE();
11045
11046 function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
11047
11048 if (IS_VAR != IS_CONST &&
11049 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
11050 if (UNEXPECTED(EG(exception) != NULL)) {
11051 HANDLE_EXCEPTION();
11052 }
11053 zend_error_noreturn(E_ERROR, "Method name must be a string");
11054 }
11055
11056 function_name_strval = Z_STRVAL_P(function_name);
11057 function_name_strlen = Z_STRLEN_P(function_name);
11058
11059 call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11060
11061 if (EXPECTED(call->object != NULL) &&
11062 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
11063 call->called_scope = Z_OBJCE_P(call->object);
11064
11065 if (IS_VAR != IS_CONST ||
11066 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
11067 zval *object = call->object;
11068
11069 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
11070 zend_error_noreturn(E_ERROR, "Object does not support method calls");
11071 }
11072
11073 /* First, locate the function. */
11074 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
11075 if (UNEXPECTED(call->fbc == NULL)) {
11076 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
11077 }
11078 if (IS_VAR == IS_CONST &&
11079 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
11080 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
11081 EXPECTED(call->object == object)) {
11082 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
11083 }
11084 }
11085 } else {
11086 if (UNEXPECTED(EG(exception) != NULL)) {
11087 zval_ptr_dtor_nogc(&free_op2.var);
11088 HANDLE_EXCEPTION();
11089 }
11090 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
11091 }
11092
11093 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
11094 call->object = NULL;
11095 } else {
11096 if (!PZVAL_IS_REF(call->object)) {
11097 Z_ADDREF_P(call->object); /* For $this pointer */
11098 } else {
11099 zval *this_ptr;
11100 ALLOC_ZVAL(this_ptr);
11101 INIT_PZVAL_COPY(this_ptr, call->object);
11102 zval_copy_ctor(this_ptr);
11103 call->object = this_ptr;
11104 }
11105 }
11106
11107 call->num_additional_args = 0;
11108 call->is_ctor_call = 0;
11109 EX(call) = call;
11110
11111 zval_ptr_dtor_nogc(&free_op2.var);
11112
11113 CHECK_EXCEPTION();
11114 ZEND_VM_NEXT_OPCODE();
11115 }
11116
ZEND_CASE_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11117 static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11118 {
11119 USE_OPLINE
11120 zend_free_op free_op1, free_op2;
11121
11122 SAVE_OPLINE();
11123 is_equal_function(&EX_T(opline->result.var).tmp_var,
11124 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
11125 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
11126
11127 zval_ptr_dtor_nogc(&free_op2.var);
11128 CHECK_EXCEPTION();
11129 ZEND_VM_NEXT_OPCODE();
11130 }
11131
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11132 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11133 {
11134 USE_OPLINE
11135 zend_free_op free_op1;
11136 zval *expr_ptr;
11137
11138 SAVE_OPLINE();
11139 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
11140 zval **expr_ptr_ptr = NULL;
11141
11142 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
11143 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
11144 }
11145 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
11146 expr_ptr = *expr_ptr_ptr;
11147 Z_ADDREF_P(expr_ptr);
11148 } else {
11149 expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11150 if (1) { /* temporary variable */
11151 zval *new_expr;
11152
11153 ALLOC_ZVAL(new_expr);
11154 INIT_PZVAL_COPY(new_expr, expr_ptr);
11155 expr_ptr = new_expr;
11156 } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
11157 zval *new_expr;
11158
11159 ALLOC_ZVAL(new_expr);
11160 INIT_PZVAL_COPY(new_expr, expr_ptr);
11161 expr_ptr = new_expr;
11162 zendi_zval_copy_ctor(*expr_ptr);
11163
11164 } else if (IS_TMP_VAR == IS_CV) {
11165 Z_ADDREF_P(expr_ptr);
11166 }
11167 }
11168
11169 if (IS_VAR != IS_UNUSED) {
11170 zend_free_op free_op2;
11171 zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
11172 ulong hval;
11173
11174 switch (Z_TYPE_P(offset)) {
11175 case IS_DOUBLE:
11176 hval = zend_dval_to_lval(Z_DVAL_P(offset));
11177 goto num_index;
11178 case IS_LONG:
11179 case IS_BOOL:
11180 hval = Z_LVAL_P(offset);
11181 num_index:
11182 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
11183 break;
11184 case IS_STRING:
11185 if (IS_VAR == IS_CONST) {
11186 hval = Z_HASH_P(offset);
11187 } else {
11188 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
11189 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
11190 }
11191 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
11192 break;
11193 case IS_NULL:
11194 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
11195 break;
11196 default:
11197 zend_error(E_WARNING, "Illegal offset type");
11198 zval_ptr_dtor(&expr_ptr);
11199 /* do nothing */
11200 break;
11201 }
11202 zval_ptr_dtor_nogc(&free_op2.var);
11203 } else {
11204 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
11205 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
11206 zval_ptr_dtor(&expr_ptr);
11207 }
11208 }
11209 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
11210
11211 }
11212 CHECK_EXCEPTION();
11213 ZEND_VM_NEXT_OPCODE();
11214 }
11215
ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11216 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11217 {
11218 USE_OPLINE
11219
11220 array_init(&EX_T(opline->result.var).tmp_var);
11221 if (IS_TMP_VAR == IS_UNUSED) {
11222 ZEND_VM_NEXT_OPCODE();
11223 #if 0 || IS_TMP_VAR != IS_UNUSED
11224 } else {
11225 return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11226 #endif
11227 }
11228 }
11229
ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11230 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11231 {
11232 USE_OPLINE
11233 zval tmp, *varname;
11234 HashTable *target_symbol_table;
11235 zend_free_op free_op1;
11236
11237 SAVE_OPLINE();
11238 if (IS_TMP_VAR == IS_CV &&
11239 IS_VAR == IS_UNUSED &&
11240 (opline->extended_value & ZEND_QUICK_SET)) {
11241 if (EG(active_symbol_table)) {
11242 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
11243
11244 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
11245 EX_CV(opline->op1.var) = NULL;
11246 } else if (EX_CV(opline->op1.var)) {
11247 zval_ptr_dtor(EX_CV(opline->op1.var));
11248 EX_CV(opline->op1.var) = NULL;
11249 }
11250 CHECK_EXCEPTION();
11251 ZEND_VM_NEXT_OPCODE();
11252 }
11253
11254 varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11255
11256 if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
11257 ZVAL_COPY_VALUE(&tmp, varname);
11258 zval_copy_ctor(&tmp);
11259 convert_to_string(&tmp);
11260 varname = &tmp;
11261 } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11262 Z_ADDREF_P(varname);
11263 }
11264
11265 if (IS_VAR != IS_UNUSED) {
11266 zend_class_entry *ce;
11267
11268 if (IS_VAR == IS_CONST) {
11269 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
11270 ce = CACHED_PTR(opline->op2.literal->cache_slot);
11271 } else {
11272 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
11273 if (UNEXPECTED(EG(exception) != NULL)) {
11274 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11275 zval_dtor(&tmp);
11276 } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11277 zval_ptr_dtor(&varname);
11278 }
11279 zval_dtor(free_op1.var);
11280 HANDLE_EXCEPTION();
11281 }
11282 if (UNEXPECTED(ce == NULL)) {
11283 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
11284 }
11285 CACHE_PTR(opline->op2.literal->cache_slot, ce);
11286 }
11287 } else {
11288 ce = EX_T(opline->op2.var).class_entry;
11289 }
11290 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
11291 } else {
11292 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
11293
11294 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
11295 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
11296 }
11297
11298 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11299 zval_dtor(&tmp);
11300 } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11301 zval_ptr_dtor(&varname);
11302 }
11303 zval_dtor(free_op1.var);
11304 CHECK_EXCEPTION();
11305 ZEND_VM_NEXT_OPCODE();
11306 }
11307
ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11308 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11309 {
11310 USE_OPLINE
11311 zval **value;
11312 zend_bool isset = 1;
11313
11314 SAVE_OPLINE();
11315 if (IS_TMP_VAR == IS_CV &&
11316 IS_VAR == IS_UNUSED &&
11317 (opline->extended_value & ZEND_QUICK_SET)) {
11318 if (EX_CV(opline->op1.var)) {
11319 value = EX_CV(opline->op1.var);
11320 } else if (EG(active_symbol_table)) {
11321 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
11322
11323 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
11324 isset = 0;
11325 }
11326 } else {
11327 isset = 0;
11328 }
11329 } else {
11330 HashTable *target_symbol_table;
11331 zend_free_op free_op1;
11332 zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11333
11334 if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
11335 ZVAL_COPY_VALUE(&tmp, varname);
11336 zval_copy_ctor(&tmp);
11337 convert_to_string(&tmp);
11338 varname = &tmp;
11339 }
11340
11341 if (IS_VAR != IS_UNUSED) {
11342 zend_class_entry *ce;
11343
11344 if (IS_VAR == IS_CONST) {
11345 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
11346 ce = CACHED_PTR(opline->op2.literal->cache_slot);
11347 } else {
11348 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
11349 if (UNEXPECTED(ce == NULL)) {
11350 CHECK_EXCEPTION();
11351 ZEND_VM_NEXT_OPCODE();
11352 }
11353 CACHE_PTR(opline->op2.literal->cache_slot, ce);
11354 }
11355 } else {
11356 ce = EX_T(opline->op2.var).class_entry;
11357 }
11358 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
11359 if (!value) {
11360 isset = 0;
11361 }
11362 } else {
11363 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
11364 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
11365 isset = 0;
11366 }
11367 }
11368
11369 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11370 zval_dtor(&tmp);
11371 }
11372 zval_dtor(free_op1.var);
11373 }
11374
11375 if (opline->extended_value & ZEND_ISSET) {
11376 if (isset && Z_TYPE_PP(value) != IS_NULL) {
11377 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
11378 } else {
11379 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
11380 }
11381 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
11382 if (!isset || !i_zend_is_true(*value)) {
11383 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
11384 } else {
11385 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
11386 }
11387 }
11388
11389 CHECK_EXCEPTION();
11390 ZEND_VM_NEXT_OPCODE();
11391 }
11392
ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11393 static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11394 {
11395 USE_OPLINE
11396
11397 /* The generator object is stored in return_value_ptr_ptr */
11398 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
11399
11400 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
11401 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
11402 }
11403
11404 /* Destroy the previously yielded value */
11405 if (generator->value) {
11406 zval_ptr_dtor(&generator->value);
11407 }
11408
11409 /* Destroy the previously yielded key */
11410 if (generator->key) {
11411 zval_ptr_dtor(&generator->key);
11412 }
11413
11414 /* Set the new yielded value */
11415 if (IS_TMP_VAR != IS_UNUSED) {
11416 zend_free_op free_op1;
11417
11418 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
11419 /* Constants and temporary variables aren't yieldable by reference,
11420 * but we still allow them with a notice. */
11421 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
11422 zval *value, *copy;
11423
11424 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11425
11426 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11427 ALLOC_ZVAL(copy);
11428 INIT_PZVAL_COPY(copy, value);
11429
11430 /* Temporary variables don't need ctor copying */
11431 if (!1) {
11432 zval_copy_ctor(copy);
11433 }
11434
11435 generator->value = copy;
11436 } else {
11437 zval **value_ptr = NULL;
11438
11439 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
11440 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
11441 }
11442
11443 /* If a function call result is yielded and the function did
11444 * not return by reference we throw a notice. */
11445 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
11446 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
11447 && EX_T(opline->op1.var).var.fcall_returned_reference)
11448 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
11449 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11450
11451 Z_ADDREF_PP(value_ptr);
11452 generator->value = *value_ptr;
11453 } else {
11454 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
11455 Z_ADDREF_PP(value_ptr);
11456 generator->value = *value_ptr;
11457 }
11458
11459 }
11460 } else {
11461 zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11462
11463 /* Consts, temporary variables and references need copying */
11464 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
11465 || PZVAL_IS_REF(value)
11466 ) {
11467 zval *copy;
11468
11469 ALLOC_ZVAL(copy);
11470 INIT_PZVAL_COPY(copy, value);
11471
11472 /* Temporary variables don't need ctor copying */
11473 if (!1) {
11474 zval_copy_ctor(copy);
11475 }
11476
11477 generator->value = copy;
11478
11479 } else {
11480 if (IS_TMP_VAR == IS_CV) {
11481 Z_ADDREF_P(value);
11482 }
11483 generator->value = value;
11484 }
11485 }
11486 } else {
11487 /* If no value was specified yield null */
11488 Z_ADDREF(EG(uninitialized_zval));
11489 generator->value = &EG(uninitialized_zval);
11490 }
11491
11492 /* Set the new yielded key */
11493 if (IS_VAR != IS_UNUSED) {
11494 zend_free_op free_op2;
11495 zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
11496
11497 /* Consts, temporary variables and references need copying */
11498 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
11499 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
11500 ) {
11501 zval *copy;
11502
11503 ALLOC_ZVAL(copy);
11504 INIT_PZVAL_COPY(copy, key);
11505
11506 /* Temporary variables don't need ctor copying */
11507 if (!0) {
11508 zval_copy_ctor(copy);
11509 }
11510
11511 generator->key = copy;
11512 } else {
11513 Z_ADDREF_P(key);
11514 generator->key = key;
11515 }
11516
11517 if (Z_TYPE_P(generator->key) == IS_LONG
11518 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
11519 ) {
11520 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
11521 }
11522
11523 zval_ptr_dtor_nogc(&free_op2.var);
11524 } else {
11525 /* If no key was specified we use auto-increment keys */
11526 generator->largest_used_integer_key++;
11527
11528 ALLOC_INIT_ZVAL(generator->key);
11529 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
11530 }
11531
11532 if (RETURN_VALUE_USED(opline)) {
11533 /* If the return value of yield is used set the send
11534 * target and initialize it to NULL */
11535 generator->send_target = &EX_T(opline->result.var).var.ptr;
11536 Z_ADDREF(EG(uninitialized_zval));
11537 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
11538 } else {
11539 generator->send_target = NULL;
11540 }
11541
11542 /* We increment to the next op, so we are at the correct position when the
11543 * generator is resumed. */
11544 ZEND_VM_INC_OPCODE();
11545
11546 /* The GOTO VM uses a local opline variable. We need to set the opline
11547 * variable in execute_data so we don't resume at an old position. */
11548 SAVE_OPLINE();
11549
11550 ZEND_VM_RETURN();
11551 }
11552
ZEND_POW_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11553 static int ZEND_FASTCALL ZEND_POW_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11554 {
11555 USE_OPLINE
11556 zend_free_op free_op1, free_op2;
11557
11558 SAVE_OPLINE();
11559 pow_function(&EX_T(opline->result.var).tmp_var,
11560 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
11561 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
11562 zval_dtor(free_op1.var);
11563 zval_ptr_dtor_nogc(&free_op2.var);
11564 CHECK_EXCEPTION();
11565 ZEND_VM_NEXT_OPCODE();
11566 }
11567
zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,ZEND_OPCODE_HANDLER_ARGS)11568 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
11569 {
11570 USE_OPLINE
11571 zend_free_op free_op1;
11572 zval *varname;
11573 zval **retval;
11574 zval tmp_varname;
11575 HashTable *target_symbol_table;
11576 ulong hash_value;
11577
11578 SAVE_OPLINE();
11579 varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11580
11581 if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
11582 ZVAL_COPY_VALUE(&tmp_varname, varname);
11583 zval_copy_ctor(&tmp_varname);
11584 Z_SET_REFCOUNT(tmp_varname, 1);
11585 Z_UNSET_ISREF(tmp_varname);
11586 convert_to_string(&tmp_varname);
11587 varname = &tmp_varname;
11588 }
11589
11590 if (IS_UNUSED != IS_UNUSED) {
11591 zend_class_entry *ce;
11592
11593 if (IS_UNUSED == IS_CONST) {
11594 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
11595 ce = CACHED_PTR(opline->op2.literal->cache_slot);
11596 } else {
11597 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
11598 if (UNEXPECTED(ce == NULL)) {
11599 if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
11600 zval_dtor(&tmp_varname);
11601 }
11602 zval_dtor(free_op1.var);
11603 CHECK_EXCEPTION();
11604 ZEND_VM_NEXT_OPCODE();
11605 }
11606 CACHE_PTR(opline->op2.literal->cache_slot, ce);
11607 }
11608 } else {
11609 ce = EX_T(opline->op2.var).class_entry;
11610 }
11611 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
11612 zval_dtor(free_op1.var);
11613 } else {
11614 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
11615 /*
11616 if (!target_symbol_table) {
11617 CHECK_EXCEPTION();
11618 ZEND_VM_NEXT_OPCODE();
11619 }
11620 */
11621 if (IS_TMP_VAR == IS_CONST) {
11622 hash_value = Z_HASH_P(varname);
11623 } else {
11624 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
11625 }
11626
11627 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
11628 switch (type) {
11629 case BP_VAR_R:
11630 case BP_VAR_UNSET:
11631 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
11632 /* break missing intentionally */
11633 case BP_VAR_IS:
11634 retval = &EG(uninitialized_zval_ptr);
11635 break;
11636 case BP_VAR_RW:
11637 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
11638 /* break missing intentionally */
11639 case BP_VAR_W:
11640 Z_ADDREF_P(&EG(uninitialized_zval));
11641 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
11642 break;
11643 EMPTY_SWITCH_DEFAULT_CASE()
11644 }
11645 }
11646 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
11647 case ZEND_FETCH_GLOBAL:
11648 if (IS_TMP_VAR != IS_TMP_VAR) {
11649 zval_dtor(free_op1.var);
11650 }
11651 break;
11652 case ZEND_FETCH_LOCAL:
11653 zval_dtor(free_op1.var);
11654 break;
11655 case ZEND_FETCH_STATIC:
11656 zval_update_constant(retval, 1 TSRMLS_CC);
11657 break;
11658 case ZEND_FETCH_GLOBAL_LOCK:
11659 if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
11660 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
11661 }
11662 break;
11663 }
11664 }
11665
11666
11667 if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
11668 zval_dtor(&tmp_varname);
11669 }
11670 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
11671 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
11672 }
11673 PZVAL_LOCK(*retval);
11674 switch (type) {
11675 case BP_VAR_R:
11676 case BP_VAR_IS:
11677 EX_T(opline->result.var).var.ptr = *retval;
11678 break;
11679 case BP_VAR_UNSET: {
11680 zend_free_op free_res;
11681
11682 PZVAL_UNLOCK(*retval, &free_res);
11683 if (retval != &EG(uninitialized_zval_ptr)) {
11684 SEPARATE_ZVAL_IF_NOT_REF(retval);
11685 }
11686 PZVAL_LOCK(*retval);
11687 FREE_OP_VAR_PTR(free_res);
11688 }
11689 /* break missing intentionally */
11690 default:
11691 EX_T(opline->result.var).var.ptr_ptr = retval;
11692 break;
11693 }
11694 CHECK_EXCEPTION();
11695 ZEND_VM_NEXT_OPCODE();
11696 }
11697
ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11698 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11699 {
11700 return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11701 }
11702
ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11703 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11704 {
11705 return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11706 }
11707
ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11708 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11709 {
11710 return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11711 }
11712
ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11713 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11714 {
11715 USE_OPLINE
11716
11717 return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11718 }
11719
ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11720 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11721 {
11722 return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11723 }
11724
ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11725 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11726 {
11727 return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11728 }
11729
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11730 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11731 {
11732 USE_OPLINE
11733 zend_free_op free_op1;
11734 zval *expr_ptr;
11735
11736 SAVE_OPLINE();
11737 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
11738 zval **expr_ptr_ptr = NULL;
11739
11740 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
11741 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
11742 }
11743 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
11744 expr_ptr = *expr_ptr_ptr;
11745 Z_ADDREF_P(expr_ptr);
11746 } else {
11747 expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11748 if (1) { /* temporary variable */
11749 zval *new_expr;
11750
11751 ALLOC_ZVAL(new_expr);
11752 INIT_PZVAL_COPY(new_expr, expr_ptr);
11753 expr_ptr = new_expr;
11754 } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
11755 zval *new_expr;
11756
11757 ALLOC_ZVAL(new_expr);
11758 INIT_PZVAL_COPY(new_expr, expr_ptr);
11759 expr_ptr = new_expr;
11760 zendi_zval_copy_ctor(*expr_ptr);
11761
11762 } else if (IS_TMP_VAR == IS_CV) {
11763 Z_ADDREF_P(expr_ptr);
11764 }
11765 }
11766
11767 if (IS_UNUSED != IS_UNUSED) {
11768
11769 zval *offset = NULL;
11770 ulong hval;
11771
11772 switch (Z_TYPE_P(offset)) {
11773 case IS_DOUBLE:
11774 hval = zend_dval_to_lval(Z_DVAL_P(offset));
11775 goto num_index;
11776 case IS_LONG:
11777 case IS_BOOL:
11778 hval = Z_LVAL_P(offset);
11779 num_index:
11780 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
11781 break;
11782 case IS_STRING:
11783 if (IS_UNUSED == IS_CONST) {
11784 hval = Z_HASH_P(offset);
11785 } else {
11786 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
11787 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
11788 }
11789 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
11790 break;
11791 case IS_NULL:
11792 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
11793 break;
11794 default:
11795 zend_error(E_WARNING, "Illegal offset type");
11796 zval_ptr_dtor(&expr_ptr);
11797 /* do nothing */
11798 break;
11799 }
11800
11801 } else {
11802 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
11803 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
11804 zval_ptr_dtor(&expr_ptr);
11805 }
11806 }
11807 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
11808
11809 }
11810 CHECK_EXCEPTION();
11811 ZEND_VM_NEXT_OPCODE();
11812 }
11813
ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11814 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11815 {
11816 USE_OPLINE
11817
11818 array_init(&EX_T(opline->result.var).tmp_var);
11819 if (IS_TMP_VAR == IS_UNUSED) {
11820 ZEND_VM_NEXT_OPCODE();
11821 #if 0 || IS_TMP_VAR != IS_UNUSED
11822 } else {
11823 return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11824 #endif
11825 }
11826 }
11827
ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11828 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11829 {
11830 USE_OPLINE
11831 zval tmp, *varname;
11832 HashTable *target_symbol_table;
11833 zend_free_op free_op1;
11834
11835 SAVE_OPLINE();
11836 if (IS_TMP_VAR == IS_CV &&
11837 IS_UNUSED == IS_UNUSED &&
11838 (opline->extended_value & ZEND_QUICK_SET)) {
11839 if (EG(active_symbol_table)) {
11840 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
11841
11842 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
11843 EX_CV(opline->op1.var) = NULL;
11844 } else if (EX_CV(opline->op1.var)) {
11845 zval_ptr_dtor(EX_CV(opline->op1.var));
11846 EX_CV(opline->op1.var) = NULL;
11847 }
11848 CHECK_EXCEPTION();
11849 ZEND_VM_NEXT_OPCODE();
11850 }
11851
11852 varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11853
11854 if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
11855 ZVAL_COPY_VALUE(&tmp, varname);
11856 zval_copy_ctor(&tmp);
11857 convert_to_string(&tmp);
11858 varname = &tmp;
11859 } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11860 Z_ADDREF_P(varname);
11861 }
11862
11863 if (IS_UNUSED != IS_UNUSED) {
11864 zend_class_entry *ce;
11865
11866 if (IS_UNUSED == IS_CONST) {
11867 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
11868 ce = CACHED_PTR(opline->op2.literal->cache_slot);
11869 } else {
11870 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
11871 if (UNEXPECTED(EG(exception) != NULL)) {
11872 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11873 zval_dtor(&tmp);
11874 } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11875 zval_ptr_dtor(&varname);
11876 }
11877 zval_dtor(free_op1.var);
11878 HANDLE_EXCEPTION();
11879 }
11880 if (UNEXPECTED(ce == NULL)) {
11881 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
11882 }
11883 CACHE_PTR(opline->op2.literal->cache_slot, ce);
11884 }
11885 } else {
11886 ce = EX_T(opline->op2.var).class_entry;
11887 }
11888 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
11889 } else {
11890 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
11891
11892 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
11893 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
11894 }
11895
11896 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11897 zval_dtor(&tmp);
11898 } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11899 zval_ptr_dtor(&varname);
11900 }
11901 zval_dtor(free_op1.var);
11902 CHECK_EXCEPTION();
11903 ZEND_VM_NEXT_OPCODE();
11904 }
11905
ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11906 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11907 {
11908 USE_OPLINE
11909 zval **value;
11910 zend_bool isset = 1;
11911
11912 SAVE_OPLINE();
11913 if (IS_TMP_VAR == IS_CV &&
11914 IS_UNUSED == IS_UNUSED &&
11915 (opline->extended_value & ZEND_QUICK_SET)) {
11916 if (EX_CV(opline->op1.var)) {
11917 value = EX_CV(opline->op1.var);
11918 } else if (EG(active_symbol_table)) {
11919 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
11920
11921 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
11922 isset = 0;
11923 }
11924 } else {
11925 isset = 0;
11926 }
11927 } else {
11928 HashTable *target_symbol_table;
11929 zend_free_op free_op1;
11930 zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11931
11932 if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
11933 ZVAL_COPY_VALUE(&tmp, varname);
11934 zval_copy_ctor(&tmp);
11935 convert_to_string(&tmp);
11936 varname = &tmp;
11937 }
11938
11939 if (IS_UNUSED != IS_UNUSED) {
11940 zend_class_entry *ce;
11941
11942 if (IS_UNUSED == IS_CONST) {
11943 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
11944 ce = CACHED_PTR(opline->op2.literal->cache_slot);
11945 } else {
11946 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
11947 if (UNEXPECTED(ce == NULL)) {
11948 CHECK_EXCEPTION();
11949 ZEND_VM_NEXT_OPCODE();
11950 }
11951 CACHE_PTR(opline->op2.literal->cache_slot, ce);
11952 }
11953 } else {
11954 ce = EX_T(opline->op2.var).class_entry;
11955 }
11956 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
11957 if (!value) {
11958 isset = 0;
11959 }
11960 } else {
11961 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
11962 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
11963 isset = 0;
11964 }
11965 }
11966
11967 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11968 zval_dtor(&tmp);
11969 }
11970 zval_dtor(free_op1.var);
11971 }
11972
11973 if (opline->extended_value & ZEND_ISSET) {
11974 if (isset && Z_TYPE_PP(value) != IS_NULL) {
11975 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
11976 } else {
11977 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
11978 }
11979 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
11980 if (!isset || !i_zend_is_true(*value)) {
11981 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
11982 } else {
11983 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
11984 }
11985 }
11986
11987 CHECK_EXCEPTION();
11988 ZEND_VM_NEXT_OPCODE();
11989 }
11990
ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11991 static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11992 {
11993 USE_OPLINE
11994
11995 /* The generator object is stored in return_value_ptr_ptr */
11996 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
11997
11998 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
11999 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
12000 }
12001
12002 /* Destroy the previously yielded value */
12003 if (generator->value) {
12004 zval_ptr_dtor(&generator->value);
12005 }
12006
12007 /* Destroy the previously yielded key */
12008 if (generator->key) {
12009 zval_ptr_dtor(&generator->key);
12010 }
12011
12012 /* Set the new yielded value */
12013 if (IS_TMP_VAR != IS_UNUSED) {
12014 zend_free_op free_op1;
12015
12016 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
12017 /* Constants and temporary variables aren't yieldable by reference,
12018 * but we still allow them with a notice. */
12019 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
12020 zval *value, *copy;
12021
12022 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12023
12024 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12025 ALLOC_ZVAL(copy);
12026 INIT_PZVAL_COPY(copy, value);
12027
12028 /* Temporary variables don't need ctor copying */
12029 if (!1) {
12030 zval_copy_ctor(copy);
12031 }
12032
12033 generator->value = copy;
12034 } else {
12035 zval **value_ptr = NULL;
12036
12037 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
12038 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
12039 }
12040
12041 /* If a function call result is yielded and the function did
12042 * not return by reference we throw a notice. */
12043 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
12044 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
12045 && EX_T(opline->op1.var).var.fcall_returned_reference)
12046 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
12047 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12048
12049 Z_ADDREF_PP(value_ptr);
12050 generator->value = *value_ptr;
12051 } else {
12052 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
12053 Z_ADDREF_PP(value_ptr);
12054 generator->value = *value_ptr;
12055 }
12056
12057 }
12058 } else {
12059 zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12060
12061 /* Consts, temporary variables and references need copying */
12062 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
12063 || PZVAL_IS_REF(value)
12064 ) {
12065 zval *copy;
12066
12067 ALLOC_ZVAL(copy);
12068 INIT_PZVAL_COPY(copy, value);
12069
12070 /* Temporary variables don't need ctor copying */
12071 if (!1) {
12072 zval_copy_ctor(copy);
12073 }
12074
12075 generator->value = copy;
12076
12077 } else {
12078 if (IS_TMP_VAR == IS_CV) {
12079 Z_ADDREF_P(value);
12080 }
12081 generator->value = value;
12082 }
12083 }
12084 } else {
12085 /* If no value was specified yield null */
12086 Z_ADDREF(EG(uninitialized_zval));
12087 generator->value = &EG(uninitialized_zval);
12088 }
12089
12090 /* Set the new yielded key */
12091 if (IS_UNUSED != IS_UNUSED) {
12092
12093 zval *key = NULL;
12094
12095 /* Consts, temporary variables and references need copying */
12096 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
12097 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
12098 ) {
12099 zval *copy;
12100
12101 ALLOC_ZVAL(copy);
12102 INIT_PZVAL_COPY(copy, key);
12103
12104 /* Temporary variables don't need ctor copying */
12105 if (!0) {
12106 zval_copy_ctor(copy);
12107 }
12108
12109 generator->key = copy;
12110 } else {
12111 Z_ADDREF_P(key);
12112 generator->key = key;
12113 }
12114
12115 if (Z_TYPE_P(generator->key) == IS_LONG
12116 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
12117 ) {
12118 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
12119 }
12120
12121 } else {
12122 /* If no key was specified we use auto-increment keys */
12123 generator->largest_used_integer_key++;
12124
12125 ALLOC_INIT_ZVAL(generator->key);
12126 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
12127 }
12128
12129 if (RETURN_VALUE_USED(opline)) {
12130 /* If the return value of yield is used set the send
12131 * target and initialize it to NULL */
12132 generator->send_target = &EX_T(opline->result.var).var.ptr;
12133 Z_ADDREF(EG(uninitialized_zval));
12134 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
12135 } else {
12136 generator->send_target = NULL;
12137 }
12138
12139 /* We increment to the next op, so we are at the correct position when the
12140 * generator is resumed. */
12141 ZEND_VM_INC_OPCODE();
12142
12143 /* The GOTO VM uses a local opline variable. We need to set the opline
12144 * variable in execute_data so we don't resume at an old position. */
12145 SAVE_OPLINE();
12146
12147 ZEND_VM_RETURN();
12148 }
12149
ZEND_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12150 static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12151 {
12152 USE_OPLINE
12153 zend_free_op free_op1;
12154
12155 SAVE_OPLINE();
12156 fast_add_function(&EX_T(opline->result.var).tmp_var,
12157 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12158 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12159 zval_dtor(free_op1.var);
12160
12161 CHECK_EXCEPTION();
12162 ZEND_VM_NEXT_OPCODE();
12163 }
12164
ZEND_SUB_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12165 static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12166 {
12167 USE_OPLINE
12168 zend_free_op free_op1;
12169
12170 SAVE_OPLINE();
12171 fast_sub_function(&EX_T(opline->result.var).tmp_var,
12172 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12173 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12174 zval_dtor(free_op1.var);
12175
12176 CHECK_EXCEPTION();
12177 ZEND_VM_NEXT_OPCODE();
12178 }
12179
ZEND_MUL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12180 static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12181 {
12182 USE_OPLINE
12183 zend_free_op free_op1;
12184
12185 SAVE_OPLINE();
12186 fast_mul_function(&EX_T(opline->result.var).tmp_var,
12187 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12188 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12189 zval_dtor(free_op1.var);
12190
12191 CHECK_EXCEPTION();
12192 ZEND_VM_NEXT_OPCODE();
12193 }
12194
ZEND_DIV_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12195 static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12196 {
12197 USE_OPLINE
12198 zend_free_op free_op1;
12199
12200 SAVE_OPLINE();
12201 fast_div_function(&EX_T(opline->result.var).tmp_var,
12202 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12203 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12204 zval_dtor(free_op1.var);
12205
12206 CHECK_EXCEPTION();
12207 ZEND_VM_NEXT_OPCODE();
12208 }
12209
ZEND_MOD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12210 static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12211 {
12212 USE_OPLINE
12213 zend_free_op free_op1;
12214
12215 SAVE_OPLINE();
12216 fast_mod_function(&EX_T(opline->result.var).tmp_var,
12217 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12218 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12219 zval_dtor(free_op1.var);
12220
12221 CHECK_EXCEPTION();
12222 ZEND_VM_NEXT_OPCODE();
12223 }
12224
ZEND_SL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12225 static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12226 {
12227 USE_OPLINE
12228 zend_free_op free_op1;
12229
12230 SAVE_OPLINE();
12231 shift_left_function(&EX_T(opline->result.var).tmp_var,
12232 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12233 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12234 zval_dtor(free_op1.var);
12235
12236 CHECK_EXCEPTION();
12237 ZEND_VM_NEXT_OPCODE();
12238 }
12239
ZEND_SR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12240 static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12241 {
12242 USE_OPLINE
12243 zend_free_op free_op1;
12244
12245 SAVE_OPLINE();
12246 shift_right_function(&EX_T(opline->result.var).tmp_var,
12247 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12248 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12249 zval_dtor(free_op1.var);
12250
12251 CHECK_EXCEPTION();
12252 ZEND_VM_NEXT_OPCODE();
12253 }
12254
ZEND_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12255 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12256 {
12257 USE_OPLINE
12258 zend_free_op free_op1;
12259
12260 SAVE_OPLINE();
12261 concat_function(&EX_T(opline->result.var).tmp_var,
12262 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12263 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12264 zval_dtor(free_op1.var);
12265
12266 CHECK_EXCEPTION();
12267 ZEND_VM_NEXT_OPCODE();
12268 }
12269
ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12270 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12271 {
12272 USE_OPLINE
12273 zend_free_op free_op1;
12274
12275 SAVE_OPLINE();
12276 is_identical_function(&EX_T(opline->result.var).tmp_var,
12277 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12278 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12279 zval_dtor(free_op1.var);
12280
12281 CHECK_EXCEPTION();
12282 ZEND_VM_NEXT_OPCODE();
12283 }
12284
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12285 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12286 {
12287 USE_OPLINE
12288 zend_free_op free_op1;
12289 zval *result = &EX_T(opline->result.var).tmp_var;
12290
12291 SAVE_OPLINE();
12292 is_identical_function(result,
12293 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12294 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12295 Z_LVAL_P(result) = !Z_LVAL_P(result);
12296 zval_dtor(free_op1.var);
12297
12298 CHECK_EXCEPTION();
12299 ZEND_VM_NEXT_OPCODE();
12300 }
12301
ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12302 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12303 {
12304 USE_OPLINE
12305 zend_free_op free_op1;
12306 zval *result = &EX_T(opline->result.var).tmp_var;
12307
12308 SAVE_OPLINE();
12309 ZVAL_BOOL(result, fast_equal_function(result,
12310 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12311 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
12312 zval_dtor(free_op1.var);
12313
12314 CHECK_EXCEPTION();
12315 ZEND_VM_NEXT_OPCODE();
12316 }
12317
ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12318 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12319 {
12320 USE_OPLINE
12321 zend_free_op free_op1;
12322 zval *result = &EX_T(opline->result.var).tmp_var;
12323
12324 SAVE_OPLINE();
12325 ZVAL_BOOL(result, fast_not_equal_function(result,
12326 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12327 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
12328 zval_dtor(free_op1.var);
12329
12330 CHECK_EXCEPTION();
12331 ZEND_VM_NEXT_OPCODE();
12332 }
12333
ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12334 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12335 {
12336 USE_OPLINE
12337 zend_free_op free_op1;
12338 zval *result = &EX_T(opline->result.var).tmp_var;
12339
12340 SAVE_OPLINE();
12341 ZVAL_BOOL(result, fast_is_smaller_function(result,
12342 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12343 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
12344 zval_dtor(free_op1.var);
12345
12346 CHECK_EXCEPTION();
12347 ZEND_VM_NEXT_OPCODE();
12348 }
12349
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12350 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12351 {
12352 USE_OPLINE
12353 zend_free_op free_op1;
12354 zval *result = &EX_T(opline->result.var).tmp_var;
12355
12356 SAVE_OPLINE();
12357 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
12358 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12359 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
12360 zval_dtor(free_op1.var);
12361
12362 CHECK_EXCEPTION();
12363 ZEND_VM_NEXT_OPCODE();
12364 }
12365
ZEND_BW_OR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12366 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12367 {
12368 USE_OPLINE
12369 zend_free_op free_op1;
12370
12371 SAVE_OPLINE();
12372 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
12373 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12374 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12375 zval_dtor(free_op1.var);
12376
12377 CHECK_EXCEPTION();
12378 ZEND_VM_NEXT_OPCODE();
12379 }
12380
ZEND_BW_AND_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12381 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12382 {
12383 USE_OPLINE
12384 zend_free_op free_op1;
12385
12386 SAVE_OPLINE();
12387 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
12388 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12389 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12390 zval_dtor(free_op1.var);
12391
12392 CHECK_EXCEPTION();
12393 ZEND_VM_NEXT_OPCODE();
12394 }
12395
ZEND_BW_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12396 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12397 {
12398 USE_OPLINE
12399 zend_free_op free_op1;
12400
12401 SAVE_OPLINE();
12402 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
12403 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12404 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12405 zval_dtor(free_op1.var);
12406
12407 CHECK_EXCEPTION();
12408 ZEND_VM_NEXT_OPCODE();
12409 }
12410
ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12411 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12412 {
12413 USE_OPLINE
12414 zend_free_op free_op1;
12415
12416 SAVE_OPLINE();
12417 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
12418 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12419 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12420 zval_dtor(free_op1.var);
12421
12422 CHECK_EXCEPTION();
12423 ZEND_VM_NEXT_OPCODE();
12424 }
12425
ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12426 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12427 {
12428 USE_OPLINE
12429 zend_free_op free_op1;
12430 zval *container;
12431
12432 SAVE_OPLINE();
12433 container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12434 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
12435
12436 if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
12437 zval_dtor(free_op1.var);
12438 }
12439 CHECK_EXCEPTION();
12440 ZEND_VM_NEXT_OPCODE();
12441 }
12442
ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12443 static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12444 {
12445 USE_OPLINE
12446
12447 zval *str = &EX_T(opline->result.var).tmp_var;
12448 zval *var;
12449 zval var_copy;
12450 int use_copy = 0;
12451
12452 SAVE_OPLINE();
12453 var = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
12454
12455 if (IS_TMP_VAR == IS_UNUSED) {
12456 /* Initialize for erealloc in add_string_to_string */
12457 Z_STRVAL_P(str) = NULL;
12458 Z_STRLEN_P(str) = 0;
12459 Z_TYPE_P(str) = IS_STRING;
12460
12461 INIT_PZVAL(str);
12462 }
12463
12464 if (Z_TYPE_P(var) != IS_STRING) {
12465 zend_make_printable_zval(var, &var_copy, &use_copy);
12466
12467 if (use_copy) {
12468 var = &var_copy;
12469 }
12470 }
12471 add_string_to_string(str, str, var);
12472
12473 if (use_copy) {
12474 zval_dtor(var);
12475 }
12476 /* original comment, possibly problematic:
12477 * FREE_OP is missing intentionally here - we're always working on the same temporary variable
12478 * (Zeev): I don't think it's problematic, we only use variables
12479 * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
12480 * string offsets or overloaded objects
12481 */
12482
12483 CHECK_EXCEPTION();
12484 ZEND_VM_NEXT_OPCODE();
12485 }
12486
ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12487 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12488 {
12489 USE_OPLINE
12490 zval *function_name;
12491 char *function_name_strval;
12492 int function_name_strlen;
12493 zend_free_op free_op1;
12494 call_slot *call = EX(call_slots) + opline->result.num;
12495
12496 SAVE_OPLINE();
12497
12498 function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
12499
12500 if (IS_CV != IS_CONST &&
12501 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12502 if (UNEXPECTED(EG(exception) != NULL)) {
12503 HANDLE_EXCEPTION();
12504 }
12505 zend_error_noreturn(E_ERROR, "Method name must be a string");
12506 }
12507
12508 function_name_strval = Z_STRVAL_P(function_name);
12509 function_name_strlen = Z_STRLEN_P(function_name);
12510
12511 call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12512
12513 if (EXPECTED(call->object != NULL) &&
12514 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
12515 call->called_scope = Z_OBJCE_P(call->object);
12516
12517 if (IS_CV != IS_CONST ||
12518 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
12519 zval *object = call->object;
12520
12521 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
12522 zend_error_noreturn(E_ERROR, "Object does not support method calls");
12523 }
12524
12525 /* First, locate the function. */
12526 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
12527 if (UNEXPECTED(call->fbc == NULL)) {
12528 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
12529 }
12530 if (IS_CV == IS_CONST &&
12531 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
12532 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
12533 EXPECTED(call->object == object)) {
12534 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
12535 }
12536 }
12537 } else {
12538 if (UNEXPECTED(EG(exception) != NULL)) {
12539
12540 HANDLE_EXCEPTION();
12541 }
12542 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
12543 }
12544
12545 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
12546 call->object = NULL;
12547 } else {
12548 if (!PZVAL_IS_REF(call->object)) {
12549 Z_ADDREF_P(call->object); /* For $this pointer */
12550 } else {
12551 zval *this_ptr;
12552 ALLOC_ZVAL(this_ptr);
12553 INIT_PZVAL_COPY(this_ptr, call->object);
12554 zval_copy_ctor(this_ptr);
12555 call->object = this_ptr;
12556 }
12557 }
12558
12559 call->num_additional_args = 0;
12560 call->is_ctor_call = 0;
12561 EX(call) = call;
12562
12563
12564 CHECK_EXCEPTION();
12565 ZEND_VM_NEXT_OPCODE();
12566 }
12567
ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12568 static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12569 {
12570 USE_OPLINE
12571 zend_free_op free_op1;
12572
12573 SAVE_OPLINE();
12574 is_equal_function(&EX_T(opline->result.var).tmp_var,
12575 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12576 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12577
12578 CHECK_EXCEPTION();
12579 ZEND_VM_NEXT_OPCODE();
12580 }
12581
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12582 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12583 {
12584 USE_OPLINE
12585 zend_free_op free_op1;
12586 zval *expr_ptr;
12587
12588 SAVE_OPLINE();
12589 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
12590 zval **expr_ptr_ptr = NULL;
12591
12592 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
12593 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
12594 }
12595 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
12596 expr_ptr = *expr_ptr_ptr;
12597 Z_ADDREF_P(expr_ptr);
12598 } else {
12599 expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12600 if (1) { /* temporary variable */
12601 zval *new_expr;
12602
12603 ALLOC_ZVAL(new_expr);
12604 INIT_PZVAL_COPY(new_expr, expr_ptr);
12605 expr_ptr = new_expr;
12606 } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
12607 zval *new_expr;
12608
12609 ALLOC_ZVAL(new_expr);
12610 INIT_PZVAL_COPY(new_expr, expr_ptr);
12611 expr_ptr = new_expr;
12612 zendi_zval_copy_ctor(*expr_ptr);
12613
12614 } else if (IS_TMP_VAR == IS_CV) {
12615 Z_ADDREF_P(expr_ptr);
12616 }
12617 }
12618
12619 if (IS_CV != IS_UNUSED) {
12620
12621 zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
12622 ulong hval;
12623
12624 switch (Z_TYPE_P(offset)) {
12625 case IS_DOUBLE:
12626 hval = zend_dval_to_lval(Z_DVAL_P(offset));
12627 goto num_index;
12628 case IS_LONG:
12629 case IS_BOOL:
12630 hval = Z_LVAL_P(offset);
12631 num_index:
12632 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
12633 break;
12634 case IS_STRING:
12635 if (IS_CV == IS_CONST) {
12636 hval = Z_HASH_P(offset);
12637 } else {
12638 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
12639 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
12640 }
12641 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
12642 break;
12643 case IS_NULL:
12644 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
12645 break;
12646 default:
12647 zend_error(E_WARNING, "Illegal offset type");
12648 zval_ptr_dtor(&expr_ptr);
12649 /* do nothing */
12650 break;
12651 }
12652
12653 } else {
12654 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
12655 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
12656 zval_ptr_dtor(&expr_ptr);
12657 }
12658 }
12659 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
12660
12661 }
12662 CHECK_EXCEPTION();
12663 ZEND_VM_NEXT_OPCODE();
12664 }
12665
ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12666 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12667 {
12668 USE_OPLINE
12669
12670 array_init(&EX_T(opline->result.var).tmp_var);
12671 if (IS_TMP_VAR == IS_UNUSED) {
12672 ZEND_VM_NEXT_OPCODE();
12673 #if 0 || IS_TMP_VAR != IS_UNUSED
12674 } else {
12675 return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12676 #endif
12677 }
12678 }
12679
ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12680 static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12681 {
12682 USE_OPLINE
12683
12684 /* The generator object is stored in return_value_ptr_ptr */
12685 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
12686
12687 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
12688 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
12689 }
12690
12691 /* Destroy the previously yielded value */
12692 if (generator->value) {
12693 zval_ptr_dtor(&generator->value);
12694 }
12695
12696 /* Destroy the previously yielded key */
12697 if (generator->key) {
12698 zval_ptr_dtor(&generator->key);
12699 }
12700
12701 /* Set the new yielded value */
12702 if (IS_TMP_VAR != IS_UNUSED) {
12703 zend_free_op free_op1;
12704
12705 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
12706 /* Constants and temporary variables aren't yieldable by reference,
12707 * but we still allow them with a notice. */
12708 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
12709 zval *value, *copy;
12710
12711 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12712
12713 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12714 ALLOC_ZVAL(copy);
12715 INIT_PZVAL_COPY(copy, value);
12716
12717 /* Temporary variables don't need ctor copying */
12718 if (!1) {
12719 zval_copy_ctor(copy);
12720 }
12721
12722 generator->value = copy;
12723 } else {
12724 zval **value_ptr = NULL;
12725
12726 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
12727 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
12728 }
12729
12730 /* If a function call result is yielded and the function did
12731 * not return by reference we throw a notice. */
12732 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
12733 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
12734 && EX_T(opline->op1.var).var.fcall_returned_reference)
12735 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
12736 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12737
12738 Z_ADDREF_PP(value_ptr);
12739 generator->value = *value_ptr;
12740 } else {
12741 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
12742 Z_ADDREF_PP(value_ptr);
12743 generator->value = *value_ptr;
12744 }
12745
12746 }
12747 } else {
12748 zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12749
12750 /* Consts, temporary variables and references need copying */
12751 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
12752 || PZVAL_IS_REF(value)
12753 ) {
12754 zval *copy;
12755
12756 ALLOC_ZVAL(copy);
12757 INIT_PZVAL_COPY(copy, value);
12758
12759 /* Temporary variables don't need ctor copying */
12760 if (!1) {
12761 zval_copy_ctor(copy);
12762 }
12763
12764 generator->value = copy;
12765
12766 } else {
12767 if (IS_TMP_VAR == IS_CV) {
12768 Z_ADDREF_P(value);
12769 }
12770 generator->value = value;
12771 }
12772 }
12773 } else {
12774 /* If no value was specified yield null */
12775 Z_ADDREF(EG(uninitialized_zval));
12776 generator->value = &EG(uninitialized_zval);
12777 }
12778
12779 /* Set the new yielded key */
12780 if (IS_CV != IS_UNUSED) {
12781
12782 zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
12783
12784 /* Consts, temporary variables and references need copying */
12785 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
12786 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
12787 ) {
12788 zval *copy;
12789
12790 ALLOC_ZVAL(copy);
12791 INIT_PZVAL_COPY(copy, key);
12792
12793 /* Temporary variables don't need ctor copying */
12794 if (!0) {
12795 zval_copy_ctor(copy);
12796 }
12797
12798 generator->key = copy;
12799 } else {
12800 Z_ADDREF_P(key);
12801 generator->key = key;
12802 }
12803
12804 if (Z_TYPE_P(generator->key) == IS_LONG
12805 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
12806 ) {
12807 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
12808 }
12809
12810 } else {
12811 /* If no key was specified we use auto-increment keys */
12812 generator->largest_used_integer_key++;
12813
12814 ALLOC_INIT_ZVAL(generator->key);
12815 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
12816 }
12817
12818 if (RETURN_VALUE_USED(opline)) {
12819 /* If the return value of yield is used set the send
12820 * target and initialize it to NULL */
12821 generator->send_target = &EX_T(opline->result.var).var.ptr;
12822 Z_ADDREF(EG(uninitialized_zval));
12823 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
12824 } else {
12825 generator->send_target = NULL;
12826 }
12827
12828 /* We increment to the next op, so we are at the correct position when the
12829 * generator is resumed. */
12830 ZEND_VM_INC_OPCODE();
12831
12832 /* The GOTO VM uses a local opline variable. We need to set the opline
12833 * variable in execute_data so we don't resume at an old position. */
12834 SAVE_OPLINE();
12835
12836 ZEND_VM_RETURN();
12837 }
12838
ZEND_POW_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12839 static int ZEND_FASTCALL ZEND_POW_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12840 {
12841 USE_OPLINE
12842 zend_free_op free_op1;
12843
12844 SAVE_OPLINE();
12845 pow_function(&EX_T(opline->result.var).tmp_var,
12846 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12847 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12848 zval_dtor(free_op1.var);
12849
12850 CHECK_EXCEPTION();
12851 ZEND_VM_NEXT_OPCODE();
12852 }
12853
ZEND_BW_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12854 static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12855 {
12856 USE_OPLINE
12857 zend_free_op free_op1;
12858
12859 SAVE_OPLINE();
12860 bitwise_not_function(&EX_T(opline->result.var).tmp_var,
12861 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
12862 zval_ptr_dtor_nogc(&free_op1.var);
12863 CHECK_EXCEPTION();
12864 ZEND_VM_NEXT_OPCODE();
12865 }
12866
ZEND_BOOL_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12867 static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12868 {
12869 USE_OPLINE
12870 zend_free_op free_op1;
12871
12872 SAVE_OPLINE();
12873 boolean_not_function(&EX_T(opline->result.var).tmp_var,
12874 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
12875 zval_ptr_dtor_nogc(&free_op1.var);
12876 CHECK_EXCEPTION();
12877 ZEND_VM_NEXT_OPCODE();
12878 }
12879
ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12880 static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12881 {
12882 USE_OPLINE
12883 zend_free_op free_op1;
12884 zval **var_ptr;
12885
12886 SAVE_OPLINE();
12887 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12888
12889 if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
12890 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
12891 }
12892 if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
12893 if (RETURN_VALUE_USED(opline)) {
12894 PZVAL_LOCK(&EG(uninitialized_zval));
12895 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
12896 }
12897 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12898 CHECK_EXCEPTION();
12899 ZEND_VM_NEXT_OPCODE();
12900 }
12901
12902 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
12903
12904 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
12905 && Z_OBJ_HANDLER_PP(var_ptr, get)
12906 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
12907 /* proxy object */
12908 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
12909 Z_ADDREF_P(val);
12910 fast_increment_function(val);
12911 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
12912 zval_ptr_dtor(&val);
12913 } else {
12914 fast_increment_function(*var_ptr);
12915 }
12916
12917 if (RETURN_VALUE_USED(opline)) {
12918 PZVAL_LOCK(*var_ptr);
12919 EX_T(opline->result.var).var.ptr = *var_ptr;
12920 }
12921
12922 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12923 CHECK_EXCEPTION();
12924 ZEND_VM_NEXT_OPCODE();
12925 }
12926
ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12927 static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12928 {
12929 USE_OPLINE
12930 zend_free_op free_op1;
12931 zval **var_ptr;
12932
12933 SAVE_OPLINE();
12934 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12935
12936 if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
12937 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
12938 }
12939 if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
12940 if (RETURN_VALUE_USED(opline)) {
12941 PZVAL_LOCK(&EG(uninitialized_zval));
12942 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
12943 }
12944 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12945 CHECK_EXCEPTION();
12946 ZEND_VM_NEXT_OPCODE();
12947 }
12948
12949 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
12950
12951 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
12952 && Z_OBJ_HANDLER_PP(var_ptr, get)
12953 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
12954 /* proxy object */
12955 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
12956 Z_ADDREF_P(val);
12957 fast_decrement_function(val);
12958 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
12959 zval_ptr_dtor(&val);
12960 } else {
12961 fast_decrement_function(*var_ptr);
12962 }
12963
12964 if (RETURN_VALUE_USED(opline)) {
12965 PZVAL_LOCK(*var_ptr);
12966 EX_T(opline->result.var).var.ptr = *var_ptr;
12967 }
12968
12969 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12970 CHECK_EXCEPTION();
12971 ZEND_VM_NEXT_OPCODE();
12972 }
12973
ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12974 static int ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12975 {
12976 USE_OPLINE
12977 zend_free_op free_op1;
12978 zval **var_ptr, *retval;
12979
12980 SAVE_OPLINE();
12981 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12982
12983 if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
12984 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
12985 }
12986 if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
12987 ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
12988 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12989 CHECK_EXCEPTION();
12990 ZEND_VM_NEXT_OPCODE();
12991 }
12992
12993 retval = &EX_T(opline->result.var).tmp_var;
12994 ZVAL_COPY_VALUE(retval, *var_ptr);
12995 zendi_zval_copy_ctor(*retval);
12996
12997 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
12998
12999 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
13000 && Z_OBJ_HANDLER_PP(var_ptr, get)
13001 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
13002 /* proxy object */
13003 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
13004 Z_ADDREF_P(val);
13005 fast_increment_function(val);
13006 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
13007 zval_ptr_dtor(&val);
13008 } else {
13009 fast_increment_function(*var_ptr);
13010 }
13011
13012 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13013 CHECK_EXCEPTION();
13014 ZEND_VM_NEXT_OPCODE();
13015 }
13016
ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13017 static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13018 {
13019 USE_OPLINE
13020 zend_free_op free_op1;
13021 zval **var_ptr, *retval;
13022
13023 SAVE_OPLINE();
13024 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13025
13026 if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
13027 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
13028 }
13029 if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
13030 ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
13031 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13032 CHECK_EXCEPTION();
13033 ZEND_VM_NEXT_OPCODE();
13034 }
13035
13036 retval = &EX_T(opline->result.var).tmp_var;
13037 ZVAL_COPY_VALUE(retval, *var_ptr);
13038 zendi_zval_copy_ctor(*retval);
13039
13040 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
13041
13042 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
13043 && Z_OBJ_HANDLER_PP(var_ptr, get)
13044 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
13045 /* proxy object */
13046 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
13047 Z_ADDREF_P(val);
13048 fast_decrement_function(val);
13049 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
13050 zval_ptr_dtor(&val);
13051 } else {
13052 fast_decrement_function(*var_ptr);
13053 }
13054
13055 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13056 CHECK_EXCEPTION();
13057 ZEND_VM_NEXT_OPCODE();
13058 }
13059
ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13060 static int ZEND_FASTCALL ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13061 {
13062 USE_OPLINE
13063 zend_free_op free_op1;
13064 zval *z;
13065
13066 SAVE_OPLINE();
13067 z = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13068
13069 if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
13070 INIT_PZVAL(z);
13071 }
13072 zend_print_variable(z);
13073
13074 zval_ptr_dtor_nogc(&free_op1.var);
13075 CHECK_EXCEPTION();
13076 ZEND_VM_NEXT_OPCODE();
13077 }
13078
ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13079 static int ZEND_FASTCALL ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13080 {
13081 USE_OPLINE
13082
13083 ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
13084 return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13085 }
13086
ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13087 static int ZEND_FASTCALL ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13088 {
13089 USE_OPLINE
13090 zend_free_op free_op1;
13091 zval *val;
13092 int ret;
13093
13094 SAVE_OPLINE();
13095 val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13096
13097 if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
13098 ret = Z_LVAL_P(val);
13099 } else {
13100 ret = i_zend_is_true(val);
13101 zval_ptr_dtor_nogc(&free_op1.var);
13102 if (UNEXPECTED(EG(exception) != NULL)) {
13103 HANDLE_EXCEPTION();
13104 }
13105 }
13106 if (!ret) {
13107 #if DEBUG_ZEND>=2
13108 printf("Conditional jmp to %d\n", opline->op2.opline_num);
13109 #endif
13110 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
13111 ZEND_VM_CONTINUE();
13112 }
13113
13114 ZEND_VM_NEXT_OPCODE();
13115 }
13116
ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13117 static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13118 {
13119 USE_OPLINE
13120 zend_free_op free_op1;
13121 zval *val;
13122 int ret;
13123
13124 SAVE_OPLINE();
13125 val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13126
13127 if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
13128 ret = Z_LVAL_P(val);
13129 } else {
13130 ret = i_zend_is_true(val);
13131 zval_ptr_dtor_nogc(&free_op1.var);
13132 if (UNEXPECTED(EG(exception) != NULL)) {
13133 HANDLE_EXCEPTION();
13134 }
13135 }
13136 if (ret) {
13137 #if DEBUG_ZEND>=2
13138 printf("Conditional jmp to %d\n", opline->op2.opline_num);
13139 #endif
13140 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
13141 ZEND_VM_CONTINUE();
13142 }
13143
13144 ZEND_VM_NEXT_OPCODE();
13145 }
13146
ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13147 static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13148 {
13149 USE_OPLINE
13150 zend_free_op free_op1;
13151 zval *val;
13152 int retval;
13153
13154 SAVE_OPLINE();
13155 val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13156
13157 if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
13158 retval = Z_LVAL_P(val);
13159 } else {
13160 retval = i_zend_is_true(val);
13161 zval_ptr_dtor_nogc(&free_op1.var);
13162 if (UNEXPECTED(EG(exception) != NULL)) {
13163 HANDLE_EXCEPTION();
13164 }
13165 }
13166 if (EXPECTED(retval != 0)) {
13167 #if DEBUG_ZEND>=2
13168 printf("Conditional jmp on true to %d\n", opline->extended_value);
13169 #endif
13170 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
13171 ZEND_VM_CONTINUE(); /* CHECK_ME */
13172 } else {
13173 #if DEBUG_ZEND>=2
13174 printf("Conditional jmp on false to %d\n", opline->op2.opline_num);
13175 #endif
13176 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
13177 ZEND_VM_CONTINUE(); /* CHECK_ME */
13178 }
13179 }
13180
ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13181 static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13182 {
13183 USE_OPLINE
13184 zend_free_op free_op1;
13185 zval *val;
13186 int retval;
13187
13188 SAVE_OPLINE();
13189 val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13190
13191 if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
13192 retval = Z_LVAL_P(val);
13193 } else {
13194 retval = i_zend_is_true(val);
13195 zval_ptr_dtor_nogc(&free_op1.var);
13196 if (UNEXPECTED(EG(exception) != NULL)) {
13197 HANDLE_EXCEPTION();
13198 }
13199 }
13200 Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
13201 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
13202 if (!retval) {
13203 #if DEBUG_ZEND>=2
13204 printf("Conditional jmp to %d\n", opline->op2.opline_num);
13205 #endif
13206 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
13207 ZEND_VM_CONTINUE();
13208 }
13209 ZEND_VM_NEXT_OPCODE();
13210 }
13211
ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13212 static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13213 {
13214 USE_OPLINE
13215 zend_free_op free_op1;
13216 zval *val;
13217 int retval;
13218
13219 SAVE_OPLINE();
13220 val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13221
13222 if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
13223 retval = Z_LVAL_P(val);
13224 } else {
13225 retval = i_zend_is_true(val);
13226 zval_ptr_dtor_nogc(&free_op1.var);
13227 if (UNEXPECTED(EG(exception) != NULL)) {
13228 HANDLE_EXCEPTION();
13229 }
13230 }
13231 Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
13232 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
13233 if (retval) {
13234 #if DEBUG_ZEND>=2
13235 printf("Conditional jmp to %d\n", opline->op2.opline_num);
13236 #endif
13237 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
13238 ZEND_VM_CONTINUE();
13239 }
13240 ZEND_VM_NEXT_OPCODE();
13241 }
13242
ZEND_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13243 static int ZEND_FASTCALL ZEND_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13244 {
13245 USE_OPLINE
13246
13247 SAVE_OPLINE();
13248 if (IS_VAR == IS_TMP_VAR) {
13249 zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
13250 } else {
13251 zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
13252 }
13253 CHECK_EXCEPTION();
13254 ZEND_VM_NEXT_OPCODE();
13255 }
13256
ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13257 static int ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13258 {
13259 USE_OPLINE
13260 zval *retval_ptr;
13261 zend_free_op free_op1;
13262
13263 SAVE_OPLINE();
13264 retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13265
13266 if (!EG(return_value_ptr_ptr)) {
13267 zval_ptr_dtor_nogc(&free_op1.var);
13268 } else {
13269 if (IS_VAR == IS_CONST ||
13270 IS_VAR == IS_TMP_VAR ||
13271 PZVAL_IS_REF(retval_ptr)) {
13272 zval *ret;
13273
13274 ALLOC_ZVAL(ret);
13275 INIT_PZVAL_COPY(ret, retval_ptr);
13276 if (IS_VAR != IS_TMP_VAR) {
13277 zval_copy_ctor(ret);
13278 }
13279 *EG(return_value_ptr_ptr) = ret;
13280 zval_ptr_dtor_nogc(&free_op1.var);
13281 } else if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) &&
13282 retval_ptr == &EG(uninitialized_zval)) {
13283 zval *ret;
13284
13285 if (IS_VAR == IS_VAR) {
13286 Z_DELREF_P(retval_ptr);
13287 }
13288 ALLOC_INIT_ZVAL(ret);
13289 *EG(return_value_ptr_ptr) = ret;
13290 } else {
13291 *EG(return_value_ptr_ptr) = retval_ptr;
13292 if (IS_VAR == IS_CV) {
13293 Z_ADDREF_P(retval_ptr);
13294 }
13295 }
13296 }
13297 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13298 }
13299
ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13300 static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13301 {
13302 USE_OPLINE
13303 zval *retval_ptr;
13304 zval **retval_ptr_ptr;
13305 zend_free_op free_op1;
13306
13307 SAVE_OPLINE();
13308
13309 do {
13310 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR ||
13311 (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
13312 /* Not supposed to happen, but we'll allow it */
13313 zend_error(E_NOTICE, "Only variable references should be returned by reference");
13314
13315 retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13316 if (!EG(return_value_ptr_ptr)) {
13317 if (IS_VAR == IS_TMP_VAR) {
13318 zval_ptr_dtor_nogc(&free_op1.var);
13319 }
13320 } else if (!0) { /* Not a temp var */
13321 zval *ret;
13322
13323 ALLOC_ZVAL(ret);
13324 INIT_PZVAL_COPY(ret, retval_ptr);
13325 zval_copy_ctor(ret);
13326 *EG(return_value_ptr_ptr) = ret;
13327 } else {
13328 zval *ret;
13329
13330 ALLOC_ZVAL(ret);
13331 INIT_PZVAL_COPY(ret, retval_ptr);
13332 *EG(return_value_ptr_ptr) = ret;
13333 }
13334 break;
13335 }
13336
13337 retval_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13338
13339 if (IS_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
13340 zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
13341 }
13342
13343 if (IS_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
13344 if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
13345 EX_T(opline->op1.var).var.fcall_returned_reference) {
13346 } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
13347 zend_error(E_NOTICE, "Only variable references should be returned by reference");
13348 if (EG(return_value_ptr_ptr)) {
13349 zval *ret;
13350
13351 ALLOC_ZVAL(ret);
13352 INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
13353 zval_copy_ctor(ret);
13354 *EG(return_value_ptr_ptr) = ret;
13355 }
13356 break;
13357 }
13358 }
13359
13360 if (EG(return_value_ptr_ptr)) {
13361 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
13362 Z_ADDREF_PP(retval_ptr_ptr);
13363
13364 *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
13365 }
13366 } while (0);
13367
13368 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13369 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13370 }
13371
ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13372 static int ZEND_FASTCALL ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13373 {
13374 USE_OPLINE
13375 zval *value;
13376 zval *exception;
13377 zend_free_op free_op1;
13378
13379 SAVE_OPLINE();
13380 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13381
13382 if (IS_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
13383 if (UNEXPECTED(EG(exception) != NULL)) {
13384 HANDLE_EXCEPTION();
13385 }
13386 zend_error_noreturn(E_ERROR, "Can only throw objects");
13387 }
13388
13389 zend_exception_save(TSRMLS_C);
13390 /* Not sure if a complete copy is what we want here */
13391 ALLOC_ZVAL(exception);
13392 INIT_PZVAL_COPY(exception, value);
13393 if (!0) {
13394 zval_copy_ctor(exception);
13395 }
13396
13397 zend_throw_exception_object(exception TSRMLS_CC);
13398 zend_exception_restore(TSRMLS_C);
13399 zval_ptr_dtor_nogc(&free_op1.var);
13400 HANDLE_EXCEPTION();
13401 }
13402
zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)13403 static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
13404 {
13405 USE_OPLINE
13406 zval *varptr;
13407 zend_free_op free_op1;
13408 varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13409
13410 if (varptr == &EG(uninitialized_zval)) {
13411 if (IS_VAR == IS_VAR) {
13412 Z_DELREF_P(varptr);
13413 }
13414 ALLOC_INIT_ZVAL(varptr);
13415 } else if (PZVAL_IS_REF(varptr)) {
13416 if (IS_VAR == IS_CV ||
13417 (IS_VAR == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) {
13418 zval *original_var = varptr;
13419
13420 ALLOC_ZVAL(varptr);
13421 INIT_PZVAL_COPY(varptr, original_var);
13422 zval_copy_ctor(varptr);
13423 zval_ptr_dtor_nogc(&free_op1.var);
13424 } else {
13425 Z_UNSET_ISREF_P(varptr);
13426 }
13427 } else if (IS_VAR == IS_CV) {
13428 Z_ADDREF_P(varptr);
13429 }
13430 zend_vm_stack_push(varptr TSRMLS_CC);
13431
13432 CHECK_EXCEPTION();
13433 ZEND_VM_NEXT_OPCODE();
13434 }
13435
ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13436 static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13437 {
13438 USE_OPLINE
13439 zend_free_op free_op1;
13440 zval *varptr;
13441
13442 SAVE_OPLINE();
13443 if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
13444 if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
13445 return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13446 }
13447 } else {
13448 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
13449 return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13450 }
13451 }
13452
13453 varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13454 if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
13455 EX_T(opline->op1.var).var.fcall_returned_reference) &&
13456 varptr != &EG(uninitialized_zval) &&
13457 (PZVAL_IS_REF(varptr) || Z_REFCOUNT_P(varptr) == 1)) {
13458 Z_SET_ISREF_P(varptr);
13459 if (IS_VAR == IS_CV) {
13460 Z_ADDREF_P(varptr);
13461 }
13462 zend_vm_stack_push(varptr TSRMLS_CC);
13463 } else {
13464 zval *valptr;
13465
13466 if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
13467 !(opline->extended_value & ZEND_ARG_SEND_SILENT) :
13468 !ARG_MAY_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
13469 zend_error(E_STRICT, "Only variables should be passed by reference");
13470 }
13471 ALLOC_ZVAL(valptr);
13472 INIT_PZVAL_COPY(valptr, varptr);
13473 if (!0) {
13474 zval_copy_ctor(valptr);
13475 }
13476 zval_ptr_dtor_nogc(&free_op1.var);
13477 zend_vm_stack_push(valptr TSRMLS_CC);
13478 }
13479 CHECK_EXCEPTION();
13480 ZEND_VM_NEXT_OPCODE();
13481 }
13482
ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13483 static int ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13484 {
13485 USE_OPLINE
13486 zend_free_op free_op1;
13487 zval **varptr_ptr;
13488 zval *varptr;
13489
13490 SAVE_OPLINE();
13491 varptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13492
13493 if (IS_VAR == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) {
13494 zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
13495 }
13496
13497 if (IS_VAR == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) {
13498 ALLOC_INIT_ZVAL(varptr);
13499 zend_vm_stack_push(varptr TSRMLS_CC);
13500 CHECK_EXCEPTION();
13501 ZEND_VM_NEXT_OPCODE();
13502 }
13503
13504 if (opline->extended_value == ZEND_DO_FCALL_BY_NAME &&
13505 EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
13506 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
13507 return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13508 }
13509 }
13510
13511 SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
13512 varptr = *varptr_ptr;
13513 Z_ADDREF_P(varptr);
13514 zend_vm_stack_push(varptr TSRMLS_CC);
13515
13516 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13517 CHECK_EXCEPTION();
13518 ZEND_VM_NEXT_OPCODE();
13519 }
13520
ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13521 static int ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13522 {
13523 USE_OPLINE
13524
13525 if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
13526 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
13527 return ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13528 }
13529 }
13530 SAVE_OPLINE();
13531 return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13532 }
13533
ZEND_BOOL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13534 static int ZEND_FASTCALL ZEND_BOOL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13535 {
13536 USE_OPLINE
13537 zend_free_op free_op1;
13538 zval *retval = &EX_T(opline->result.var).tmp_var;
13539
13540 SAVE_OPLINE();
13541 /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
13542 ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)));
13543 zval_ptr_dtor_nogc(&free_op1.var);
13544
13545 CHECK_EXCEPTION();
13546 ZEND_VM_NEXT_OPCODE();
13547 }
13548
ZEND_SWITCH_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13549 static int ZEND_FASTCALL ZEND_SWITCH_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13550 {
13551 USE_OPLINE
13552
13553 SAVE_OPLINE();
13554 zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
13555 CHECK_EXCEPTION();
13556 ZEND_VM_NEXT_OPCODE();
13557 }
13558
ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13559 static int ZEND_FASTCALL ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13560 {
13561 USE_OPLINE
13562 zend_free_op free_op1;
13563 zval *obj;
13564 zend_class_entry *ce;
13565 zend_function *clone;
13566 zend_object_clone_obj_t clone_call;
13567
13568 SAVE_OPLINE();
13569 obj = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13570
13571 if (IS_VAR == IS_CONST ||
13572 UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
13573 if (UNEXPECTED(EG(exception) != NULL)) {
13574 HANDLE_EXCEPTION();
13575 }
13576 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
13577 }
13578
13579 ce = Z_OBJCE_P(obj);
13580 clone = ce ? ce->clone : NULL;
13581 clone_call = Z_OBJ_HT_P(obj)->clone_obj;
13582 if (UNEXPECTED(clone_call == NULL)) {
13583 if (ce) {
13584 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
13585 } else {
13586 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
13587 }
13588 }
13589
13590 if (ce && clone) {
13591 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
13592 /* Ensure that if we're calling a private function, we're allowed to do so.
13593 */
13594 if (UNEXPECTED(ce != EG(scope))) {
13595 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
13596 }
13597 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
13598 /* Ensure that if we're calling a protected function, we're allowed to do so.
13599 */
13600 if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
13601 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
13602 }
13603 }
13604 }
13605
13606 if (EXPECTED(EG(exception) == NULL)) {
13607 zval *retval;
13608
13609 ALLOC_ZVAL(retval);
13610 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
13611 Z_TYPE_P(retval) = IS_OBJECT;
13612 Z_SET_REFCOUNT_P(retval, 1);
13613 Z_SET_ISREF_P(retval);
13614 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
13615 zval_ptr_dtor(&retval);
13616 } else {
13617 EX_T(opline->result.var).var.ptr = retval;
13618 }
13619 }
13620 zval_ptr_dtor_nogc(&free_op1.var);
13621 CHECK_EXCEPTION();
13622 ZEND_VM_NEXT_OPCODE();
13623 }
13624
ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13625 static int ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13626 {
13627 USE_OPLINE
13628 zend_free_op free_op1;
13629 zval *expr;
13630 zval *result = &EX_T(opline->result.var).tmp_var;
13631
13632 SAVE_OPLINE();
13633 expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13634
13635 if (opline->extended_value != IS_STRING) {
13636 ZVAL_COPY_VALUE(result, expr);
13637 if (!0) {
13638 zendi_zval_copy_ctor(*result);
13639 }
13640 }
13641 switch (opline->extended_value) {
13642 case IS_NULL:
13643 convert_to_null(result);
13644 break;
13645 case IS_BOOL:
13646 convert_to_boolean(result);
13647 break;
13648 case IS_LONG:
13649 convert_to_long(result);
13650 break;
13651 case IS_DOUBLE:
13652 convert_to_double(result);
13653 break;
13654 case IS_STRING: {
13655 zval var_copy;
13656 int use_copy;
13657
13658 zend_make_printable_zval(expr, &var_copy, &use_copy);
13659 if (use_copy) {
13660 ZVAL_COPY_VALUE(result, &var_copy);
13661 if (0) {
13662 zval_ptr_dtor_nogc(&free_op1.var);
13663 }
13664 } else {
13665 ZVAL_COPY_VALUE(result, expr);
13666 if (!0) {
13667 zendi_zval_copy_ctor(*result);
13668 }
13669 }
13670 break;
13671 }
13672 case IS_ARRAY:
13673 convert_to_array(result);
13674 break;
13675 case IS_OBJECT:
13676 convert_to_object(result);
13677 break;
13678 }
13679 zval_ptr_dtor_nogc(&free_op1.var);
13680 CHECK_EXCEPTION();
13681 ZEND_VM_NEXT_OPCODE();
13682 }
13683
ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13684 static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13685 {
13686 USE_OPLINE
13687 zend_op_array *new_op_array=NULL;
13688 zend_free_op free_op1;
13689 zval *inc_filename;
13690 zval *tmp_inc_filename = NULL;
13691 zend_bool failure_retval=0;
13692
13693 SAVE_OPLINE();
13694 inc_filename = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13695
13696 if (inc_filename->type!=IS_STRING) {
13697 MAKE_STD_ZVAL(tmp_inc_filename);
13698 ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
13699 zval_copy_ctor(tmp_inc_filename);
13700 convert_to_string(tmp_inc_filename);
13701 inc_filename = tmp_inc_filename;
13702 }
13703
13704 if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
13705 if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
13706 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
13707 } else {
13708 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
13709 }
13710 } else {
13711 switch (opline->extended_value) {
13712 case ZEND_INCLUDE_ONCE:
13713 case ZEND_REQUIRE_ONCE: {
13714 zend_file_handle file_handle;
13715 char *resolved_path;
13716
13717 resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
13718 if (resolved_path) {
13719 failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
13720 } else {
13721 resolved_path = Z_STRVAL_P(inc_filename);
13722 }
13723
13724 if (failure_retval) {
13725 /* do nothing, file already included */
13726 } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
13727
13728 if (!file_handle.opened_path) {
13729 file_handle.opened_path = estrdup(resolved_path);
13730 }
13731
13732 if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
13733 new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
13734 zend_destroy_file_handle(&file_handle TSRMLS_CC);
13735 } else {
13736 zend_file_handle_dtor(&file_handle TSRMLS_CC);
13737 failure_retval=1;
13738 }
13739 } else {
13740 if (opline->extended_value == ZEND_INCLUDE_ONCE) {
13741 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
13742 } else {
13743 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
13744 }
13745 }
13746 if (resolved_path != Z_STRVAL_P(inc_filename)) {
13747 efree(resolved_path);
13748 }
13749 }
13750 break;
13751 case ZEND_INCLUDE:
13752 case ZEND_REQUIRE:
13753 new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC);
13754 break;
13755 case ZEND_EVAL: {
13756 char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
13757
13758 new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
13759 efree(eval_desc);
13760 }
13761 break;
13762 EMPTY_SWITCH_DEFAULT_CASE()
13763 }
13764 }
13765 if (tmp_inc_filename) {
13766 zval_ptr_dtor(&tmp_inc_filename);
13767 }
13768 zval_ptr_dtor_nogc(&free_op1.var);
13769 if (UNEXPECTED(EG(exception) != NULL)) {
13770 HANDLE_EXCEPTION();
13771 } else if (EXPECTED(new_op_array != NULL)) {
13772 EX(original_return_value) = EG(return_value_ptr_ptr);
13773 EG(active_op_array) = new_op_array;
13774 if (RETURN_VALUE_USED(opline)) {
13775 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
13776 EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
13777 } else {
13778 EG(return_value_ptr_ptr) = NULL;
13779 }
13780
13781 EX(function_state).function = (zend_function *) new_op_array;
13782 EX(object) = NULL;
13783
13784 if (!EG(active_symbol_table)) {
13785 zend_rebuild_symbol_table(TSRMLS_C);
13786 }
13787
13788 if (EXPECTED(zend_execute_ex == execute_ex)) {
13789 ZEND_VM_ENTER();
13790 } else {
13791 zend_execute(new_op_array TSRMLS_CC);
13792 }
13793
13794 EX(function_state).function = (zend_function *) EX(op_array);
13795
13796 EG(opline_ptr) = &EX(opline);
13797 EG(active_op_array) = EX(op_array);
13798 EG(return_value_ptr_ptr) = EX(original_return_value);
13799 destroy_op_array(new_op_array TSRMLS_CC);
13800 efree(new_op_array);
13801 if (UNEXPECTED(EG(exception) != NULL)) {
13802 zend_throw_exception_internal(NULL TSRMLS_CC);
13803 HANDLE_EXCEPTION();
13804 }
13805
13806 } else if (RETURN_VALUE_USED(opline)) {
13807 zval *retval;
13808
13809 ALLOC_ZVAL(retval);
13810 ZVAL_BOOL(retval, failure_retval);
13811 INIT_PZVAL(retval);
13812 EX_T(opline->result.var).var.ptr = retval;
13813 }
13814 ZEND_VM_NEXT_OPCODE();
13815 }
13816
ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13817 static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13818 {
13819 USE_OPLINE
13820 zend_free_op free_op1;
13821 zval *array_ptr, **array_ptr_ptr;
13822 HashTable *fe_ht;
13823 zend_object_iterator *iter = NULL;
13824 zend_class_entry *ce = NULL;
13825 zend_bool is_empty = 0;
13826
13827 SAVE_OPLINE();
13828
13829 if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) &&
13830 (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
13831 array_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13832 if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
13833 MAKE_STD_ZVAL(array_ptr);
13834 ZVAL_NULL(array_ptr);
13835 } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
13836 if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
13837 zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
13838 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
13839 }
13840
13841 ce = Z_OBJCE_PP(array_ptr_ptr);
13842 if (!ce || ce->get_iterator == NULL) {
13843 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
13844 Z_ADDREF_PP(array_ptr_ptr);
13845 }
13846 array_ptr = *array_ptr_ptr;
13847 } else {
13848 if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
13849 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
13850 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
13851 Z_SET_ISREF_PP(array_ptr_ptr);
13852 }
13853 }
13854 array_ptr = *array_ptr_ptr;
13855 Z_ADDREF_P(array_ptr);
13856 }
13857 } else {
13858 array_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13859 if (0) { /* IS_TMP_VAR */
13860 zval *tmp;
13861
13862 ALLOC_ZVAL(tmp);
13863 INIT_PZVAL_COPY(tmp, array_ptr);
13864 array_ptr = tmp;
13865 if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
13866 ce = Z_OBJCE_P(array_ptr);
13867 if (ce && ce->get_iterator) {
13868 Z_DELREF_P(array_ptr);
13869 }
13870 }
13871 } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
13872 ce = Z_OBJCE_P(array_ptr);
13873 if (!ce || !ce->get_iterator) {
13874 if (IS_VAR == IS_CV) {
13875 Z_ADDREF_P(array_ptr);
13876 }
13877 }
13878 } else if (IS_VAR == IS_CONST ||
13879 (IS_VAR == IS_CV &&
13880 !Z_ISREF_P(array_ptr) &&
13881 Z_REFCOUNT_P(array_ptr) > 1) ||
13882 (IS_VAR == IS_VAR &&
13883 !Z_ISREF_P(array_ptr) &&
13884 Z_REFCOUNT_P(array_ptr) > 2)) {
13885 zval *tmp;
13886
13887 if (IS_VAR == IS_VAR) {
13888 Z_DELREF_P(array_ptr);
13889 }
13890 ALLOC_ZVAL(tmp);
13891 INIT_PZVAL_COPY(tmp, array_ptr);
13892 zval_copy_ctor(tmp);
13893 array_ptr = tmp;
13894 } else if (IS_VAR == IS_CV) {
13895 Z_ADDREF_P(array_ptr);
13896 }
13897 }
13898
13899 if (ce && ce->get_iterator) {
13900 iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
13901
13902 if (IS_VAR == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
13903 zval_ptr_dtor_nogc(&free_op1.var);
13904 }
13905 if (iter && EXPECTED(EG(exception) == NULL)) {
13906 array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
13907 } else {
13908 if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
13909 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13910 }
13911 if (!EG(exception)) {
13912 zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
13913 }
13914 zend_throw_exception_internal(NULL TSRMLS_CC);
13915 HANDLE_EXCEPTION();
13916 }
13917 }
13918
13919 EX_T(opline->result.var).fe.ptr = array_ptr;
13920
13921 if (iter) {
13922 iter->index = 0;
13923 if (iter->funcs->rewind) {
13924 iter->funcs->rewind(iter TSRMLS_CC);
13925 if (UNEXPECTED(EG(exception) != NULL)) {
13926 zval_ptr_dtor(&array_ptr);
13927 if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
13928 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13929 }
13930 HANDLE_EXCEPTION();
13931 }
13932 }
13933 is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
13934 if (UNEXPECTED(EG(exception) != NULL)) {
13935 zval_ptr_dtor(&array_ptr);
13936 if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
13937 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13938 }
13939 HANDLE_EXCEPTION();
13940 }
13941 iter->index = -1; /* will be set to 0 before using next handler */
13942 } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
13943 zend_hash_internal_pointer_reset(fe_ht);
13944 if (ce) {
13945 zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
13946 while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
13947 char *str_key;
13948 uint str_key_len;
13949 ulong int_key;
13950 zend_uchar key_type;
13951
13952 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
13953 if (key_type != HASH_KEY_NON_EXISTENT &&
13954 (key_type == HASH_KEY_IS_LONG ||
13955 zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
13956 break;
13957 }
13958 zend_hash_move_forward(fe_ht);
13959 }
13960 }
13961 is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
13962 zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
13963 } else {
13964 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
13965 is_empty = 1;
13966 }
13967
13968 if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
13969 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13970 }
13971 if (is_empty) {
13972 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
13973 } else {
13974 CHECK_EXCEPTION();
13975 ZEND_VM_NEXT_OPCODE();
13976 }
13977 }
13978
ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13979 static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13980 {
13981 USE_OPLINE
13982
13983 zval *array = EX_T(opline->op1.var).fe.ptr;
13984 zval **value;
13985 HashTable *fe_ht;
13986 zend_object_iterator *iter = NULL;
13987
13988 zval *key = NULL;
13989 if (opline->extended_value & ZEND_FE_FETCH_WITH_KEY) {
13990 key = &EX_T((opline+1)->result.var).tmp_var;
13991 }
13992
13993 SAVE_OPLINE();
13994
13995 switch (zend_iterator_unwrap(array, &iter TSRMLS_CC)) {
13996 default:
13997 case ZEND_ITER_INVALID:
13998 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
13999 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
14000
14001 case ZEND_ITER_PLAIN_OBJECT: {
14002 zend_object *zobj = zend_objects_get_address(array TSRMLS_CC);
14003 int key_type;
14004 char *str_key;
14005 zend_uint str_key_len;
14006 zend_ulong int_key;
14007
14008 fe_ht = Z_OBJPROP_P(array);
14009 zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
14010 do {
14011 if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
14012 /* reached end of iteration */
14013 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
14014 }
14015 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
14016
14017 zend_hash_move_forward(fe_ht);
14018 } while (key_type != HASH_KEY_IS_LONG &&
14019 zend_check_property_access(zobj, str_key, str_key_len - 1 TSRMLS_CC) != SUCCESS);
14020
14021 if (key) {
14022 if (key_type == HASH_KEY_IS_LONG) {
14023 ZVAL_LONG(key, int_key);
14024 } else {
14025 const char *class_name, *prop_name;
14026 int prop_name_len;
14027 zend_unmangle_property_name_ex(
14028 str_key, str_key_len - 1, &class_name, &prop_name, &prop_name_len
14029 );
14030 ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
14031 }
14032 }
14033
14034 zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
14035 break;
14036 }
14037
14038 case ZEND_ITER_PLAIN_ARRAY:
14039 fe_ht = Z_ARRVAL_P(array);
14040 zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
14041 if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
14042 /* reached end of iteration */
14043 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
14044 }
14045 if (key) {
14046 zend_hash_get_current_key_zval(fe_ht, key);
14047 }
14048 zend_hash_move_forward(fe_ht);
14049 zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
14050 break;
14051
14052 case ZEND_ITER_OBJECT:
14053 /* !iter happens from exception */
14054 if (iter && ++iter->index > 0) {
14055 /* This could cause an endless loop if index becomes zero again.
14056 * In case that ever happens we need an additional flag. */
14057 iter->funcs->move_forward(iter TSRMLS_CC);
14058 if (UNEXPECTED(EG(exception) != NULL)) {
14059 zval_ptr_dtor(&array);
14060 HANDLE_EXCEPTION();
14061 }
14062 }
14063 /* If index is zero we come from FE_RESET and checked valid() already. */
14064 if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
14065 /* reached end of iteration */
14066 if (UNEXPECTED(EG(exception) != NULL)) {
14067 zval_ptr_dtor(&array);
14068 HANDLE_EXCEPTION();
14069 }
14070 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
14071 }
14072 iter->funcs->get_current_data(iter, &value TSRMLS_CC);
14073 if (UNEXPECTED(EG(exception) != NULL)) {
14074 zval_ptr_dtor(&array);
14075 HANDLE_EXCEPTION();
14076 }
14077 if (!value) {
14078 /* failure in get_current_data */
14079 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
14080 }
14081 if (key) {
14082 if (iter->funcs->get_current_key) {
14083 iter->funcs->get_current_key(iter, key TSRMLS_CC);
14084 if (UNEXPECTED(EG(exception) != NULL)) {
14085 zval_ptr_dtor(&array);
14086 HANDLE_EXCEPTION();
14087 }
14088 } else {
14089 ZVAL_LONG(key, iter->index);
14090 }
14091 }
14092 break;
14093 }
14094
14095 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
14096 SEPARATE_ZVAL_IF_NOT_REF(value);
14097 Z_SET_ISREF_PP(value);
14098 EX_T(opline->result.var).var.ptr_ptr = value;
14099 Z_ADDREF_PP(value);
14100 } else {
14101 PZVAL_LOCK(*value);
14102 EX_T(opline->result.var).var.ptr = *value;
14103 }
14104
14105 CHECK_EXCEPTION();
14106 ZEND_VM_INC_OPCODE();
14107 ZEND_VM_NEXT_OPCODE();
14108 }
14109
ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14110 static int ZEND_FASTCALL ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14111 {
14112 #if 0 || (IS_VAR != IS_UNUSED)
14113 USE_OPLINE
14114
14115 SAVE_OPLINE();
14116 if (IS_VAR != IS_UNUSED) {
14117 zend_free_op free_op1;
14118 zval *ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14119
14120 if (Z_TYPE_P(ptr) == IS_LONG) {
14121 EG(exit_status) = Z_LVAL_P(ptr);
14122 } else {
14123 zend_print_variable(ptr);
14124 }
14125 zval_ptr_dtor_nogc(&free_op1.var);
14126 }
14127 #endif
14128 zend_bailout();
14129 ZEND_VM_NEXT_OPCODE(); /* Never reached */
14130 }
14131
ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14132 static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14133 {
14134 USE_OPLINE
14135 zend_free_op free_op1;
14136 zval *value;
14137
14138 SAVE_OPLINE();
14139 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14140
14141 if (i_zend_is_true(value)) {
14142 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
14143 if (!0) {
14144 zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
14145 }
14146 zval_ptr_dtor_nogc(&free_op1.var);
14147 #if DEBUG_ZEND>=2
14148 printf("Conditional jmp to %d\n", opline->op2.opline_num);
14149 #endif
14150 ZEND_VM_JMP(opline->op2.jmp_addr);
14151 }
14152
14153 zval_ptr_dtor_nogc(&free_op1.var);
14154 CHECK_EXCEPTION();
14155 ZEND_VM_NEXT_OPCODE();
14156 }
14157
ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14158 static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14159 {
14160 USE_OPLINE
14161 zend_free_op free_op1;
14162 zval *value, *ret;
14163
14164 SAVE_OPLINE();
14165 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14166
14167 if (i_zend_is_true(value)) {
14168 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
14169 Z_ADDREF_P(value);
14170 EX_T(opline->result.var).var.ptr = value;
14171 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
14172 } else {
14173 ALLOC_ZVAL(ret);
14174 INIT_PZVAL_COPY(ret, value);
14175 EX_T(opline->result.var).var.ptr = ret;
14176 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
14177 if (!0) {
14178 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
14179 }
14180 }
14181 zval_ptr_dtor_nogc(&free_op1.var);
14182 #if DEBUG_ZEND>=2
14183 printf("Conditional jmp to %d\n", opline->op2.opline_num);
14184 #endif
14185 ZEND_VM_JMP(opline->op2.jmp_addr);
14186 }
14187
14188 zval_ptr_dtor_nogc(&free_op1.var);
14189 CHECK_EXCEPTION();
14190 ZEND_VM_NEXT_OPCODE();
14191 }
14192
ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14193 static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14194 {
14195 USE_OPLINE
14196 zend_free_op free_op1;
14197 zval *value;
14198
14199 SAVE_OPLINE();
14200 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14201
14202 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
14203 if (!0) {
14204 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
14205 }
14206 zval_ptr_dtor_nogc(&free_op1.var);
14207 CHECK_EXCEPTION();
14208 ZEND_VM_NEXT_OPCODE();
14209 }
14210
ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14211 static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14212 {
14213 USE_OPLINE
14214 zend_free_op free_op1;
14215 zval *value, *ret;
14216
14217 SAVE_OPLINE();
14218 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14219
14220 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
14221 Z_ADDREF_P(value);
14222 EX_T(opline->result.var).var.ptr = value;
14223 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
14224 } else {
14225 ALLOC_ZVAL(ret);
14226 INIT_PZVAL_COPY(ret, value);
14227 EX_T(opline->result.var).var.ptr = ret;
14228 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
14229 if (!0) {
14230 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
14231 }
14232 }
14233
14234 zval_ptr_dtor_nogc(&free_op1.var);
14235 CHECK_EXCEPTION();
14236 ZEND_VM_NEXT_OPCODE();
14237 }
14238
ZEND_INSTANCEOF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14239 static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14240 {
14241 USE_OPLINE
14242 zend_free_op free_op1;
14243 zval *expr;
14244 zend_bool result;
14245
14246 SAVE_OPLINE();
14247 expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14248
14249 if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
14250 result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
14251 } else {
14252 result = 0;
14253 }
14254 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
14255 zval_ptr_dtor_nogc(&free_op1.var);
14256 CHECK_EXCEPTION();
14257 ZEND_VM_NEXT_OPCODE();
14258 }
14259
ZEND_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14260 static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14261 {
14262 USE_OPLINE
14263 zend_free_op free_op1;
14264
14265 SAVE_OPLINE();
14266 fast_add_function(&EX_T(opline->result.var).tmp_var,
14267 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14268 opline->op2.zv TSRMLS_CC);
14269 zval_ptr_dtor_nogc(&free_op1.var);
14270
14271 CHECK_EXCEPTION();
14272 ZEND_VM_NEXT_OPCODE();
14273 }
14274
ZEND_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14275 static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14276 {
14277 USE_OPLINE
14278 zend_free_op free_op1;
14279
14280 SAVE_OPLINE();
14281 fast_sub_function(&EX_T(opline->result.var).tmp_var,
14282 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14283 opline->op2.zv TSRMLS_CC);
14284 zval_ptr_dtor_nogc(&free_op1.var);
14285
14286 CHECK_EXCEPTION();
14287 ZEND_VM_NEXT_OPCODE();
14288 }
14289
ZEND_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14290 static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14291 {
14292 USE_OPLINE
14293 zend_free_op free_op1;
14294
14295 SAVE_OPLINE();
14296 fast_mul_function(&EX_T(opline->result.var).tmp_var,
14297 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14298 opline->op2.zv TSRMLS_CC);
14299 zval_ptr_dtor_nogc(&free_op1.var);
14300
14301 CHECK_EXCEPTION();
14302 ZEND_VM_NEXT_OPCODE();
14303 }
14304
ZEND_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14305 static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14306 {
14307 USE_OPLINE
14308 zend_free_op free_op1;
14309
14310 SAVE_OPLINE();
14311 fast_div_function(&EX_T(opline->result.var).tmp_var,
14312 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14313 opline->op2.zv TSRMLS_CC);
14314 zval_ptr_dtor_nogc(&free_op1.var);
14315
14316 CHECK_EXCEPTION();
14317 ZEND_VM_NEXT_OPCODE();
14318 }
14319
ZEND_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14320 static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14321 {
14322 USE_OPLINE
14323 zend_free_op free_op1;
14324
14325 SAVE_OPLINE();
14326 fast_mod_function(&EX_T(opline->result.var).tmp_var,
14327 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14328 opline->op2.zv TSRMLS_CC);
14329 zval_ptr_dtor_nogc(&free_op1.var);
14330
14331 CHECK_EXCEPTION();
14332 ZEND_VM_NEXT_OPCODE();
14333 }
14334
ZEND_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14335 static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14336 {
14337 USE_OPLINE
14338 zend_free_op free_op1;
14339
14340 SAVE_OPLINE();
14341 shift_left_function(&EX_T(opline->result.var).tmp_var,
14342 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14343 opline->op2.zv TSRMLS_CC);
14344 zval_ptr_dtor_nogc(&free_op1.var);
14345
14346 CHECK_EXCEPTION();
14347 ZEND_VM_NEXT_OPCODE();
14348 }
14349
ZEND_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14350 static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14351 {
14352 USE_OPLINE
14353 zend_free_op free_op1;
14354
14355 SAVE_OPLINE();
14356 shift_right_function(&EX_T(opline->result.var).tmp_var,
14357 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14358 opline->op2.zv TSRMLS_CC);
14359 zval_ptr_dtor_nogc(&free_op1.var);
14360
14361 CHECK_EXCEPTION();
14362 ZEND_VM_NEXT_OPCODE();
14363 }
14364
ZEND_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14365 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14366 {
14367 USE_OPLINE
14368 zend_free_op free_op1;
14369
14370 SAVE_OPLINE();
14371 concat_function(&EX_T(opline->result.var).tmp_var,
14372 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14373 opline->op2.zv TSRMLS_CC);
14374 zval_ptr_dtor_nogc(&free_op1.var);
14375
14376 CHECK_EXCEPTION();
14377 ZEND_VM_NEXT_OPCODE();
14378 }
14379
ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14380 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14381 {
14382 USE_OPLINE
14383 zend_free_op free_op1;
14384
14385 SAVE_OPLINE();
14386 is_identical_function(&EX_T(opline->result.var).tmp_var,
14387 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14388 opline->op2.zv TSRMLS_CC);
14389 zval_ptr_dtor_nogc(&free_op1.var);
14390
14391 CHECK_EXCEPTION();
14392 ZEND_VM_NEXT_OPCODE();
14393 }
14394
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14395 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14396 {
14397 USE_OPLINE
14398 zend_free_op free_op1;
14399 zval *result = &EX_T(opline->result.var).tmp_var;
14400
14401 SAVE_OPLINE();
14402 is_identical_function(result,
14403 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14404 opline->op2.zv TSRMLS_CC);
14405 Z_LVAL_P(result) = !Z_LVAL_P(result);
14406 zval_ptr_dtor_nogc(&free_op1.var);
14407
14408 CHECK_EXCEPTION();
14409 ZEND_VM_NEXT_OPCODE();
14410 }
14411
ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14412 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14413 {
14414 USE_OPLINE
14415 zend_free_op free_op1;
14416 zval *result = &EX_T(opline->result.var).tmp_var;
14417
14418 SAVE_OPLINE();
14419 ZVAL_BOOL(result, fast_equal_function(result,
14420 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14421 opline->op2.zv TSRMLS_CC));
14422 zval_ptr_dtor_nogc(&free_op1.var);
14423
14424 CHECK_EXCEPTION();
14425 ZEND_VM_NEXT_OPCODE();
14426 }
14427
ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14428 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14429 {
14430 USE_OPLINE
14431 zend_free_op free_op1;
14432 zval *result = &EX_T(opline->result.var).tmp_var;
14433
14434 SAVE_OPLINE();
14435 ZVAL_BOOL(result, fast_not_equal_function(result,
14436 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14437 opline->op2.zv TSRMLS_CC));
14438 zval_ptr_dtor_nogc(&free_op1.var);
14439
14440 CHECK_EXCEPTION();
14441 ZEND_VM_NEXT_OPCODE();
14442 }
14443
ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14444 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14445 {
14446 USE_OPLINE
14447 zend_free_op free_op1;
14448 zval *result = &EX_T(opline->result.var).tmp_var;
14449
14450 SAVE_OPLINE();
14451 ZVAL_BOOL(result, fast_is_smaller_function(result,
14452 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14453 opline->op2.zv TSRMLS_CC));
14454 zval_ptr_dtor_nogc(&free_op1.var);
14455
14456 CHECK_EXCEPTION();
14457 ZEND_VM_NEXT_OPCODE();
14458 }
14459
ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14460 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14461 {
14462 USE_OPLINE
14463 zend_free_op free_op1;
14464 zval *result = &EX_T(opline->result.var).tmp_var;
14465
14466 SAVE_OPLINE();
14467 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
14468 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14469 opline->op2.zv TSRMLS_CC));
14470 zval_ptr_dtor_nogc(&free_op1.var);
14471
14472 CHECK_EXCEPTION();
14473 ZEND_VM_NEXT_OPCODE();
14474 }
14475
ZEND_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14476 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14477 {
14478 USE_OPLINE
14479 zend_free_op free_op1;
14480
14481 SAVE_OPLINE();
14482 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
14483 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14484 opline->op2.zv TSRMLS_CC);
14485 zval_ptr_dtor_nogc(&free_op1.var);
14486
14487 CHECK_EXCEPTION();
14488 ZEND_VM_NEXT_OPCODE();
14489 }
14490
ZEND_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14491 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14492 {
14493 USE_OPLINE
14494 zend_free_op free_op1;
14495
14496 SAVE_OPLINE();
14497 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
14498 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14499 opline->op2.zv TSRMLS_CC);
14500 zval_ptr_dtor_nogc(&free_op1.var);
14501
14502 CHECK_EXCEPTION();
14503 ZEND_VM_NEXT_OPCODE();
14504 }
14505
ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14506 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14507 {
14508 USE_OPLINE
14509 zend_free_op free_op1;
14510
14511 SAVE_OPLINE();
14512 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
14513 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14514 opline->op2.zv TSRMLS_CC);
14515 zval_ptr_dtor_nogc(&free_op1.var);
14516
14517 CHECK_EXCEPTION();
14518 ZEND_VM_NEXT_OPCODE();
14519 }
14520
ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14521 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14522 {
14523 USE_OPLINE
14524 zend_free_op free_op1;
14525
14526 SAVE_OPLINE();
14527 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
14528 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14529 opline->op2.zv TSRMLS_CC);
14530 zval_ptr_dtor_nogc(&free_op1.var);
14531
14532 CHECK_EXCEPTION();
14533 ZEND_VM_NEXT_OPCODE();
14534 }
14535
zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)14536 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
14537 {
14538 USE_OPLINE
14539 zend_free_op free_op1, free_op_data1;
14540 zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14541 zval *object;
14542 zval *property = opline->op2.zv;
14543 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
14544 int have_get_ptr = 0;
14545
14546 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
14547 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
14548 }
14549
14550 make_real_object(object_ptr TSRMLS_CC);
14551 object = *object_ptr;
14552
14553 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
14554 zend_error(E_WARNING, "Attempt to assign property of non-object");
14555
14556 FREE_OP(free_op_data1);
14557
14558 if (RETURN_VALUE_USED(opline)) {
14559 PZVAL_LOCK(&EG(uninitialized_zval));
14560 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
14561 }
14562 } else {
14563 /* here we are sure we are dealing with an object */
14564 if (0) {
14565 MAKE_REAL_ZVAL_PTR(property);
14566 }
14567
14568 /* here property is a string */
14569 if (opline->extended_value == ZEND_ASSIGN_OBJ
14570 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
14571 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14572 if (zptr != NULL) { /* NULL means no success in getting PTR */
14573 have_get_ptr = 1;
14574 if (UNEXPECTED(*zptr == &EG(error_zval))) {
14575 if (RETURN_VALUE_USED(opline)) {
14576 PZVAL_LOCK(&EG(uninitialized_zval));
14577 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
14578 }
14579 } else {
14580 SEPARATE_ZVAL_IF_NOT_REF(zptr);
14581
14582 binary_op(*zptr, *zptr, value TSRMLS_CC);
14583 if (RETURN_VALUE_USED(opline)) {
14584 PZVAL_LOCK(*zptr);
14585 EX_T(opline->result.var).var.ptr = *zptr;
14586 }
14587 }
14588 }
14589 }
14590
14591 if (!have_get_ptr) {
14592 zval *z = NULL;
14593
14594 Z_ADDREF_P(object);
14595 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
14596 if (Z_OBJ_HT_P(object)->read_property) {
14597 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14598 }
14599 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
14600 if (Z_OBJ_HT_P(object)->read_dimension) {
14601 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
14602 }
14603 }
14604 if (z) {
14605 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
14606 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
14607
14608 if (Z_REFCOUNT_P(z) == 0) {
14609 GC_REMOVE_ZVAL_FROM_BUFFER(z);
14610 zval_dtor(z);
14611 FREE_ZVAL(z);
14612 }
14613 z = value;
14614 }
14615 Z_ADDREF_P(z);
14616 SEPARATE_ZVAL_IF_NOT_REF(&z);
14617 binary_op(z, z, value TSRMLS_CC);
14618 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
14619 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14620 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
14621 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
14622 }
14623 if (RETURN_VALUE_USED(opline)) {
14624 PZVAL_LOCK(z);
14625 EX_T(opline->result.var).var.ptr = z;
14626 }
14627 zval_ptr_dtor(&z);
14628 } else {
14629 zend_error(E_WARNING, "Attempt to assign property of non-object");
14630 if (RETURN_VALUE_USED(opline)) {
14631 PZVAL_LOCK(&EG(uninitialized_zval));
14632 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
14633 }
14634 }
14635 zval_ptr_dtor(&object);
14636 }
14637
14638 if (0) {
14639 zval_ptr_dtor(&property);
14640 } else {
14641
14642 }
14643 FREE_OP(free_op_data1);
14644 }
14645
14646 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14647 /* assign_obj has two opcodes! */
14648 CHECK_EXCEPTION();
14649 ZEND_VM_INC_OPCODE();
14650 ZEND_VM_NEXT_OPCODE();
14651 }
14652
zend_binary_assign_op_helper_SPEC_VAR_CONST(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)14653 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
14654 {
14655 USE_OPLINE
14656 zend_free_op free_op1, free_op_data2, free_op_data1;
14657 zval **var_ptr;
14658 zval *value;
14659
14660 SAVE_OPLINE();
14661 switch (opline->extended_value) {
14662 case ZEND_ASSIGN_OBJ:
14663 return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14664 break;
14665 case ZEND_ASSIGN_DIM: {
14666 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14667
14668 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
14669 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
14670 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
14671 if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
14672 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
14673 }
14674 return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14675 } else {
14676 zval *dim = opline->op2.zv;
14677
14678 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC);
14679 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
14680 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
14681 }
14682 }
14683 break;
14684 default:
14685 value = opline->op2.zv;
14686 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14687 /* do nothing */
14688 break;
14689 }
14690
14691 if (UNEXPECTED(var_ptr == NULL)) {
14692 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
14693 }
14694
14695 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
14696 if (RETURN_VALUE_USED(opline)) {
14697 PZVAL_LOCK(&EG(uninitialized_zval));
14698 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
14699 }
14700
14701 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14702 CHECK_EXCEPTION();
14703 if (opline->extended_value == ZEND_ASSIGN_DIM) {
14704 ZEND_VM_INC_OPCODE();
14705 }
14706 ZEND_VM_NEXT_OPCODE();
14707 }
14708
14709 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
14710
14711 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
14712 && Z_OBJ_HANDLER_PP(var_ptr, get)
14713 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
14714 /* proxy object */
14715 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
14716 Z_ADDREF_P(objval);
14717 binary_op(objval, objval, value TSRMLS_CC);
14718 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
14719 zval_ptr_dtor(&objval);
14720 } else {
14721 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
14722 }
14723
14724 if (RETURN_VALUE_USED(opline)) {
14725 PZVAL_LOCK(*var_ptr);
14726 EX_T(opline->result.var).var.ptr = *var_ptr;
14727 }
14728
14729 if (opline->extended_value == ZEND_ASSIGN_DIM) {
14730 FREE_OP(free_op_data1);
14731 FREE_OP_VAR_PTR(free_op_data2);
14732 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14733 CHECK_EXCEPTION();
14734 ZEND_VM_INC_OPCODE();
14735 } else {
14736 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14737 CHECK_EXCEPTION();
14738 }
14739 ZEND_VM_NEXT_OPCODE();
14740 }
14741
ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14742 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14743 {
14744 return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14745 }
14746
ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14747 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14748 {
14749 return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14750 }
14751
ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14752 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14753 {
14754 return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14755 }
14756
ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14757 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14758 {
14759 return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14760 }
14761
ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14762 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14763 {
14764 return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14765 }
14766
ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14767 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14768 {
14769 return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14770 }
14771
ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14772 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14773 {
14774 return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14775 }
14776
ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14777 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14778 {
14779 return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14780 }
14781
ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14782 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14783 {
14784 return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14785 }
14786
ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14787 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14788 {
14789 return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14790 }
14791
ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14792 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14793 {
14794 return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14795 }
14796
zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)14797 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
14798 {
14799 USE_OPLINE
14800 zend_free_op free_op1;
14801 zval **object_ptr;
14802 zval *object;
14803 zval *property;
14804 zval **retval;
14805 int have_get_ptr = 0;
14806
14807 SAVE_OPLINE();
14808 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14809 property = opline->op2.zv;
14810 retval = &EX_T(opline->result.var).var.ptr;
14811
14812 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
14813 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
14814 }
14815
14816 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
14817 object = *object_ptr;
14818
14819 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
14820 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
14821
14822 if (RETURN_VALUE_USED(opline)) {
14823 PZVAL_LOCK(&EG(uninitialized_zval));
14824 *retval = &EG(uninitialized_zval);
14825 }
14826 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14827 CHECK_EXCEPTION();
14828 ZEND_VM_NEXT_OPCODE();
14829 }
14830
14831 /* here we are sure we are dealing with an object */
14832
14833 if (0) {
14834 MAKE_REAL_ZVAL_PTR(property);
14835 }
14836
14837 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
14838 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14839 if (zptr != NULL) { /* NULL means no success in getting PTR */
14840 have_get_ptr = 1;
14841 if (UNEXPECTED(*zptr == &EG(error_zval))) {
14842 if (RETURN_VALUE_USED(opline)) {
14843 PZVAL_LOCK(&EG(uninitialized_zval));
14844 *retval = &EG(uninitialized_zval);
14845 }
14846 } else {
14847 SEPARATE_ZVAL_IF_NOT_REF(zptr);
14848
14849 incdec_op(*zptr);
14850 if (RETURN_VALUE_USED(opline)) {
14851 *retval = *zptr;
14852 PZVAL_LOCK(*retval);
14853 }
14854 }
14855 }
14856 }
14857
14858 if (!have_get_ptr) {
14859 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
14860 zval *z;
14861
14862 Z_ADDREF_P(object);
14863 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14864
14865 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
14866 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
14867
14868 if (Z_REFCOUNT_P(z) == 0) {
14869 GC_REMOVE_ZVAL_FROM_BUFFER(z);
14870 zval_dtor(z);
14871 FREE_ZVAL(z);
14872 }
14873 z = value;
14874 }
14875 Z_ADDREF_P(z);
14876 SEPARATE_ZVAL_IF_NOT_REF(&z);
14877 incdec_op(z);
14878 *retval = z;
14879 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14880 zval_ptr_dtor(&object);
14881 SELECTIVE_PZVAL_LOCK(*retval, opline);
14882 zval_ptr_dtor(&z);
14883 } else {
14884 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
14885 if (RETURN_VALUE_USED(opline)) {
14886 PZVAL_LOCK(&EG(uninitialized_zval));
14887 *retval = &EG(uninitialized_zval);
14888 }
14889 }
14890 }
14891
14892 if (0) {
14893 zval_ptr_dtor(&property);
14894 } else {
14895
14896 }
14897 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14898 CHECK_EXCEPTION();
14899 ZEND_VM_NEXT_OPCODE();
14900 }
14901
ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14902 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14903 {
14904 return zend_pre_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14905 }
14906
ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14907 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14908 {
14909 return zend_pre_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14910 }
14911
zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)14912 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
14913 {
14914 USE_OPLINE
14915 zend_free_op free_op1;
14916 zval **object_ptr;
14917 zval *object;
14918 zval *property;
14919 zval *retval;
14920 int have_get_ptr = 0;
14921
14922 SAVE_OPLINE();
14923 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14924 property = opline->op2.zv;
14925 retval = &EX_T(opline->result.var).tmp_var;
14926
14927 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
14928 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
14929 }
14930
14931 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
14932 object = *object_ptr;
14933
14934 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
14935 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
14936
14937 ZVAL_NULL(retval);
14938 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14939 CHECK_EXCEPTION();
14940 ZEND_VM_NEXT_OPCODE();
14941 }
14942
14943 /* here we are sure we are dealing with an object */
14944
14945 if (0) {
14946 MAKE_REAL_ZVAL_PTR(property);
14947 }
14948
14949 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
14950 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14951 if (zptr != NULL) { /* NULL means no success in getting PTR */
14952 have_get_ptr = 1;
14953 if (UNEXPECTED(*zptr == &EG(error_zval))) {
14954 ZVAL_NULL(retval);
14955 } else {
14956 SEPARATE_ZVAL_IF_NOT_REF(zptr);
14957
14958 ZVAL_COPY_VALUE(retval, *zptr);
14959 zendi_zval_copy_ctor(*retval);
14960
14961 incdec_op(*zptr);
14962 }
14963 }
14964 }
14965
14966 if (!have_get_ptr) {
14967 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
14968 zval *z, *z_copy;
14969
14970 Z_ADDREF_P(object);
14971 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14972 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
14973 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
14974
14975 if (Z_REFCOUNT_P(z) == 0) {
14976 GC_REMOVE_ZVAL_FROM_BUFFER(z);
14977 zval_dtor(z);
14978 FREE_ZVAL(z);
14979 }
14980 z = value;
14981 }
14982 ZVAL_COPY_VALUE(retval, z);
14983 zendi_zval_copy_ctor(*retval);
14984 ALLOC_ZVAL(z_copy);
14985 INIT_PZVAL_COPY(z_copy, z);
14986 zendi_zval_copy_ctor(*z_copy);
14987 incdec_op(z_copy);
14988 Z_ADDREF_P(z);
14989 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14990 zval_ptr_dtor(&object);
14991 zval_ptr_dtor(&z_copy);
14992 zval_ptr_dtor(&z);
14993 } else {
14994 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
14995 ZVAL_NULL(retval);
14996 }
14997 }
14998
14999 if (0) {
15000 zval_ptr_dtor(&property);
15001 } else {
15002
15003 }
15004 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15005 CHECK_EXCEPTION();
15006 ZEND_VM_NEXT_OPCODE();
15007 }
15008
ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15009 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15010 {
15011 return zend_post_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15012 }
15013
ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15014 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15015 {
15016 return zend_post_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15017 }
15018
zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,ZEND_OPCODE_HANDLER_ARGS)15019 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
15020 {
15021 USE_OPLINE
15022 zend_free_op free_op1;
15023 zval *varname;
15024 zval **retval;
15025 zval tmp_varname;
15026 HashTable *target_symbol_table;
15027 ulong hash_value;
15028
15029 SAVE_OPLINE();
15030 varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15031
15032 if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
15033 ZVAL_COPY_VALUE(&tmp_varname, varname);
15034 zval_copy_ctor(&tmp_varname);
15035 Z_SET_REFCOUNT(tmp_varname, 1);
15036 Z_UNSET_ISREF(tmp_varname);
15037 convert_to_string(&tmp_varname);
15038 varname = &tmp_varname;
15039 }
15040
15041 if (IS_CONST != IS_UNUSED) {
15042 zend_class_entry *ce;
15043
15044 if (IS_CONST == IS_CONST) {
15045 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
15046 ce = CACHED_PTR(opline->op2.literal->cache_slot);
15047 } else {
15048 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
15049 if (UNEXPECTED(ce == NULL)) {
15050 if (IS_VAR != IS_CONST && varname == &tmp_varname) {
15051 zval_dtor(&tmp_varname);
15052 }
15053 zval_ptr_dtor_nogc(&free_op1.var);
15054 CHECK_EXCEPTION();
15055 ZEND_VM_NEXT_OPCODE();
15056 }
15057 CACHE_PTR(opline->op2.literal->cache_slot, ce);
15058 }
15059 } else {
15060 ce = EX_T(opline->op2.var).class_entry;
15061 }
15062 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
15063 zval_ptr_dtor_nogc(&free_op1.var);
15064 } else {
15065 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
15066 /*
15067 if (!target_symbol_table) {
15068 CHECK_EXCEPTION();
15069 ZEND_VM_NEXT_OPCODE();
15070 }
15071 */
15072 if (IS_VAR == IS_CONST) {
15073 hash_value = Z_HASH_P(varname);
15074 } else {
15075 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
15076 }
15077
15078 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
15079 switch (type) {
15080 case BP_VAR_R:
15081 case BP_VAR_UNSET:
15082 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
15083 /* break missing intentionally */
15084 case BP_VAR_IS:
15085 retval = &EG(uninitialized_zval_ptr);
15086 break;
15087 case BP_VAR_RW:
15088 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
15089 /* break missing intentionally */
15090 case BP_VAR_W:
15091 Z_ADDREF_P(&EG(uninitialized_zval));
15092 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
15093 break;
15094 EMPTY_SWITCH_DEFAULT_CASE()
15095 }
15096 }
15097 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
15098 case ZEND_FETCH_GLOBAL:
15099 if (IS_VAR != IS_TMP_VAR) {
15100 zval_ptr_dtor_nogc(&free_op1.var);
15101 }
15102 break;
15103 case ZEND_FETCH_LOCAL:
15104 zval_ptr_dtor_nogc(&free_op1.var);
15105 break;
15106 case ZEND_FETCH_STATIC:
15107 zval_update_constant(retval, 1 TSRMLS_CC);
15108 break;
15109 case ZEND_FETCH_GLOBAL_LOCK:
15110 if (IS_VAR == IS_VAR && !free_op1.var) {
15111 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
15112 }
15113 break;
15114 }
15115 }
15116
15117
15118 if (IS_VAR != IS_CONST && varname == &tmp_varname) {
15119 zval_dtor(&tmp_varname);
15120 }
15121 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
15122 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
15123 }
15124 PZVAL_LOCK(*retval);
15125 switch (type) {
15126 case BP_VAR_R:
15127 case BP_VAR_IS:
15128 EX_T(opline->result.var).var.ptr = *retval;
15129 break;
15130 case BP_VAR_UNSET: {
15131 zend_free_op free_res;
15132
15133 PZVAL_UNLOCK(*retval, &free_res);
15134 if (retval != &EG(uninitialized_zval_ptr)) {
15135 SEPARATE_ZVAL_IF_NOT_REF(retval);
15136 }
15137 PZVAL_LOCK(*retval);
15138 FREE_OP_VAR_PTR(free_res);
15139 }
15140 /* break missing intentionally */
15141 default:
15142 EX_T(opline->result.var).var.ptr_ptr = retval;
15143 break;
15144 }
15145 CHECK_EXCEPTION();
15146 ZEND_VM_NEXT_OPCODE();
15147 }
15148
ZEND_FETCH_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15149 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15150 {
15151 return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15152 }
15153
ZEND_FETCH_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15154 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15155 {
15156 return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15157 }
15158
ZEND_FETCH_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15159 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15160 {
15161 return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15162 }
15163
ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15164 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15165 {
15166 USE_OPLINE
15167
15168 return zend_fetch_var_address_helper_SPEC_VAR_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15169 }
15170
ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15171 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15172 {
15173 return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15174 }
15175
ZEND_FETCH_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15176 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15177 {
15178 return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15179 }
15180
ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15181 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15182 {
15183 USE_OPLINE
15184 zend_free_op free_op1;
15185 zval *container;
15186
15187 SAVE_OPLINE();
15188 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15189 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
15190
15191 if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
15192 zval_ptr_dtor_nogc(&free_op1.var);
15193 }
15194 CHECK_EXCEPTION();
15195 ZEND_VM_NEXT_OPCODE();
15196 }
15197
ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15198 static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15199 {
15200 USE_OPLINE
15201 zend_free_op free_op1;
15202 zval **container;
15203
15204 SAVE_OPLINE();
15205 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15206
15207 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15208 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15209 }
15210 zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
15211
15212 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15213 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15214 }
15215 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15216
15217 /* We are going to assign the result by reference */
15218 if (UNEXPECTED(opline->extended_value != 0)) {
15219 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
15220
15221 if (retval_ptr) {
15222 Z_DELREF_PP(retval_ptr);
15223 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
15224 Z_ADDREF_PP(retval_ptr);
15225 }
15226 }
15227
15228 CHECK_EXCEPTION();
15229 ZEND_VM_NEXT_OPCODE();
15230 }
15231
ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15232 static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15233 {
15234 USE_OPLINE
15235 zend_free_op free_op1;
15236 zval **container;
15237
15238 SAVE_OPLINE();
15239 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15240
15241 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15242 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15243 }
15244 zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_RW TSRMLS_CC);
15245
15246 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15247 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15248 }
15249 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15250 CHECK_EXCEPTION();
15251 ZEND_VM_NEXT_OPCODE();
15252 }
15253
ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15254 static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15255 {
15256 USE_OPLINE
15257 zend_free_op free_op1;
15258 zval *container;
15259
15260 SAVE_OPLINE();
15261 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15262 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC);
15263
15264 zval_ptr_dtor_nogc(&free_op1.var);
15265 CHECK_EXCEPTION();
15266 ZEND_VM_NEXT_OPCODE();
15267 }
15268
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15269 static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15270 {
15271 USE_OPLINE
15272 zend_free_op free_op1;
15273
15274 SAVE_OPLINE();
15275
15276 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
15277 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15278 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15279 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15280 }
15281 zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
15282 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15283 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15284 }
15285
15286 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15287 } else {
15288 zval *container;
15289
15290 if (IS_CONST == IS_UNUSED) {
15291 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
15292 }
15293 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15294 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
15295
15296 zval_ptr_dtor_nogc(&free_op1.var);
15297 }
15298 CHECK_EXCEPTION();
15299 ZEND_VM_NEXT_OPCODE();
15300 }
15301
ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15302 static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15303 {
15304 USE_OPLINE
15305 zend_free_op free_op1;
15306 zval **container;
15307
15308 SAVE_OPLINE();
15309 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15310
15311 if (IS_VAR == IS_CV) {
15312 if (container != &EG(uninitialized_zval_ptr)) {
15313 SEPARATE_ZVAL_IF_NOT_REF(container);
15314 }
15315 }
15316 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15317 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15318 }
15319 zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_UNSET TSRMLS_CC);
15320
15321 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15322 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15323 }
15324 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15325 if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
15326 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
15327 ZEND_VM_NEXT_OPCODE();
15328 } else {
15329 zend_free_op free_res;
15330 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
15331
15332 PZVAL_UNLOCK(*retval_ptr, &free_res);
15333 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
15334 SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
15335 }
15336 PZVAL_LOCK(*retval_ptr);
15337 FREE_OP_VAR_PTR(free_res);
15338 CHECK_EXCEPTION();
15339 ZEND_VM_NEXT_OPCODE();
15340 }
15341 }
15342
zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS)15343 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS)
15344 {
15345 USE_OPLINE
15346 zend_free_op free_op1;
15347 zval *container;
15348
15349 zval *offset;
15350
15351 SAVE_OPLINE();
15352 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15353 offset = opline->op2.zv;
15354
15355 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
15356 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
15357 zend_error(E_NOTICE, "Trying to get property of non-object");
15358 PZVAL_LOCK(&EG(uninitialized_zval));
15359 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15360
15361 } else {
15362 zval *retval;
15363
15364 if (0) {
15365 MAKE_REAL_ZVAL_PTR(offset);
15366 }
15367
15368 /* here we are sure we are dealing with an object */
15369 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
15370
15371 PZVAL_LOCK(retval);
15372 EX_T(opline->result.var).var.ptr = retval;
15373
15374 if (0) {
15375 zval_ptr_dtor(&offset);
15376 } else {
15377
15378 }
15379 }
15380
15381 zval_ptr_dtor_nogc(&free_op1.var);
15382 CHECK_EXCEPTION();
15383 ZEND_VM_NEXT_OPCODE();
15384 }
15385
ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15386 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15387 {
15388 return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15389 }
15390
ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15391 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15392 {
15393 USE_OPLINE
15394 zend_free_op free_op1;
15395 zval *property;
15396 zval **container;
15397
15398 SAVE_OPLINE();
15399 property = opline->op2.zv;
15400
15401 if (0) {
15402 MAKE_REAL_ZVAL_PTR(property);
15403 }
15404 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15405 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15406 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
15407 }
15408
15409 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
15410 if (0) {
15411 zval_ptr_dtor(&property);
15412 } else {
15413
15414 }
15415 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15416 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15417 }
15418 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15419
15420 /* We are going to assign the result by reference */
15421 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
15422 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
15423
15424 Z_DELREF_PP(retval_ptr);
15425 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
15426 Z_ADDREF_PP(retval_ptr);
15427 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
15428 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
15429 }
15430
15431 CHECK_EXCEPTION();
15432 ZEND_VM_NEXT_OPCODE();
15433 }
15434
ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15435 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15436 {
15437 USE_OPLINE
15438 zend_free_op free_op1;
15439 zval *property;
15440 zval **container;
15441
15442 SAVE_OPLINE();
15443 property = opline->op2.zv;
15444 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15445
15446 if (0) {
15447 MAKE_REAL_ZVAL_PTR(property);
15448 }
15449 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15450 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
15451 }
15452 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
15453 if (0) {
15454 zval_ptr_dtor(&property);
15455 } else {
15456
15457 }
15458 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15459 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15460 }
15461 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15462 CHECK_EXCEPTION();
15463 ZEND_VM_NEXT_OPCODE();
15464 }
15465
ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15466 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15467 {
15468 USE_OPLINE
15469 zend_free_op free_op1;
15470 zval *container;
15471
15472 zval *offset;
15473
15474 SAVE_OPLINE();
15475 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15476 offset = opline->op2.zv;
15477
15478 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
15479 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
15480 PZVAL_LOCK(&EG(uninitialized_zval));
15481 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15482
15483 } else {
15484 zval *retval;
15485
15486 if (0) {
15487 MAKE_REAL_ZVAL_PTR(offset);
15488 }
15489
15490 /* here we are sure we are dealing with an object */
15491 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
15492
15493 PZVAL_LOCK(retval);
15494 EX_T(opline->result.var).var.ptr = retval;
15495
15496 if (0) {
15497 zval_ptr_dtor(&offset);
15498 } else {
15499
15500 }
15501 }
15502
15503 zval_ptr_dtor_nogc(&free_op1.var);
15504 CHECK_EXCEPTION();
15505 ZEND_VM_NEXT_OPCODE();
15506 }
15507
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15508 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15509 {
15510 USE_OPLINE
15511
15512 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
15513 /* Behave like FETCH_OBJ_W */
15514 zend_free_op free_op1;
15515 zval *property;
15516 zval **container;
15517
15518 SAVE_OPLINE();
15519 property = opline->op2.zv;
15520 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15521
15522 if (0) {
15523 MAKE_REAL_ZVAL_PTR(property);
15524 }
15525 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15526 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
15527 }
15528 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
15529 if (0) {
15530 zval_ptr_dtor(&property);
15531 } else {
15532
15533 }
15534 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15535 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15536 }
15537 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15538 CHECK_EXCEPTION();
15539 ZEND_VM_NEXT_OPCODE();
15540 } else {
15541 return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15542 }
15543 }
15544
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15545 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15546 {
15547 USE_OPLINE
15548 zend_free_op free_op1, free_res;
15549 zval **container;
15550 zval *property;
15551
15552 SAVE_OPLINE();
15553 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15554 property = opline->op2.zv;
15555
15556 if (IS_VAR == IS_CV) {
15557 if (container != &EG(uninitialized_zval_ptr)) {
15558 SEPARATE_ZVAL_IF_NOT_REF(container);
15559 }
15560 }
15561 if (0) {
15562 MAKE_REAL_ZVAL_PTR(property);
15563 }
15564 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15565 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
15566 }
15567 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
15568 if (0) {
15569 zval_ptr_dtor(&property);
15570 } else {
15571
15572 }
15573 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15574 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15575 }
15576 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15577
15578 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
15579 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
15580 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
15581 }
15582 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
15583 FREE_OP_VAR_PTR(free_res);
15584 CHECK_EXCEPTION();
15585 ZEND_VM_NEXT_OPCODE();
15586 }
15587
ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15588 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15589 {
15590 USE_OPLINE
15591 zend_free_op free_op1;
15592 zval **object_ptr;
15593 zval *property_name;
15594
15595 SAVE_OPLINE();
15596 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15597 property_name = opline->op2.zv;
15598
15599 if (0) {
15600 MAKE_REAL_ZVAL_PTR(property_name);
15601 }
15602 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
15603 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15604 }
15605 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
15606 if (0) {
15607 zval_ptr_dtor(&property_name);
15608 } else {
15609
15610 }
15611 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15612 /* assign_obj has two opcodes! */
15613 CHECK_EXCEPTION();
15614 ZEND_VM_INC_OPCODE();
15615 ZEND_VM_NEXT_OPCODE();
15616 }
15617
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15618 static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15619 {
15620 USE_OPLINE
15621 zend_free_op free_op1;
15622 zval **object_ptr;
15623
15624 SAVE_OPLINE();
15625 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15626
15627 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
15628 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15629 }
15630 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
15631
15632 zval *property_name = opline->op2.zv;
15633
15634 if (0) {
15635 MAKE_REAL_ZVAL_PTR(property_name);
15636 }
15637 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
15638 if (0) {
15639 zval_ptr_dtor(&property_name);
15640 } else {
15641
15642 }
15643 } else {
15644 zend_free_op free_op_data1, free_op_data2;
15645 zval *value;
15646 zval *dim = opline->op2.zv;
15647 zval **variable_ptr_ptr;
15648
15649 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC);
15650
15651 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
15652 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
15653 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
15654 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
15655 if (RETURN_VALUE_USED(opline)) {
15656 zval *retval;
15657
15658 ALLOC_ZVAL(retval);
15659 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
15660 INIT_PZVAL(retval);
15661 EX_T(opline->result.var).var.ptr = retval;
15662 }
15663 } else if (RETURN_VALUE_USED(opline)) {
15664 PZVAL_LOCK(&EG(uninitialized_zval));
15665 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15666 }
15667 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
15668 if (IS_TMP_FREE(free_op_data1)) {
15669 zval_dtor(value);
15670 }
15671 if (RETURN_VALUE_USED(opline)) {
15672 PZVAL_LOCK(&EG(uninitialized_zval));
15673 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15674 }
15675 } else {
15676 if ((opline+1)->op1_type == IS_TMP_VAR) {
15677 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15678 } else if ((opline+1)->op1_type == IS_CONST) {
15679 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15680 } else {
15681 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15682 }
15683 if (RETURN_VALUE_USED(opline)) {
15684 PZVAL_LOCK(value);
15685 EX_T(opline->result.var).var.ptr = value;
15686 }
15687 }
15688 FREE_OP_VAR_PTR(free_op_data2);
15689 FREE_OP_IF_VAR(free_op_data1);
15690 }
15691 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15692 /* assign_dim has two opcodes! */
15693 CHECK_EXCEPTION();
15694 ZEND_VM_INC_OPCODE();
15695 ZEND_VM_NEXT_OPCODE();
15696 }
15697
ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15698 static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15699 {
15700 USE_OPLINE
15701 zend_free_op free_op1;
15702 zval *value;
15703 zval **variable_ptr_ptr;
15704
15705 SAVE_OPLINE();
15706 value = opline->op2.zv;
15707 variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15708
15709 if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
15710 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) {
15711 if (RETURN_VALUE_USED(opline)) {
15712 zval *retval;
15713
15714 ALLOC_ZVAL(retval);
15715 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
15716 INIT_PZVAL(retval);
15717 EX_T(opline->result.var).var.ptr = retval;
15718 }
15719 } else if (RETURN_VALUE_USED(opline)) {
15720 PZVAL_LOCK(&EG(uninitialized_zval));
15721 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15722 }
15723 } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
15724 if (0) {
15725 zval_dtor(value);
15726 }
15727 if (RETURN_VALUE_USED(opline)) {
15728 PZVAL_LOCK(&EG(uninitialized_zval));
15729 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15730 }
15731 } else {
15732 if (IS_CONST == IS_TMP_VAR) {
15733 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15734 } else if (IS_CONST == IS_CONST) {
15735 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15736 } else {
15737 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15738 }
15739 if (RETURN_VALUE_USED(opline)) {
15740 PZVAL_LOCK(value);
15741 EX_T(opline->result.var).var.ptr = value;
15742 }
15743 }
15744
15745 if (IS_VAR == IS_VAR && (free_op1.var != NULL)) {
15746 zval_ptr_dtor_nogc(&value);
15747 }
15748
15749 /* zend_assign_to_variable() always takes care of op2, never free it! */
15750
15751 CHECK_EXCEPTION();
15752 ZEND_VM_NEXT_OPCODE();
15753 }
15754
ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15755 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15756 {
15757 USE_OPLINE
15758 zval *function_name;
15759 char *function_name_strval;
15760 int function_name_strlen;
15761 zend_free_op free_op1;
15762 call_slot *call = EX(call_slots) + opline->result.num;
15763
15764 SAVE_OPLINE();
15765
15766 function_name = opline->op2.zv;
15767
15768 if (IS_CONST != IS_CONST &&
15769 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
15770 if (UNEXPECTED(EG(exception) != NULL)) {
15771 HANDLE_EXCEPTION();
15772 }
15773 zend_error_noreturn(E_ERROR, "Method name must be a string");
15774 }
15775
15776 function_name_strval = Z_STRVAL_P(function_name);
15777 function_name_strlen = Z_STRLEN_P(function_name);
15778
15779 call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15780
15781 if (EXPECTED(call->object != NULL) &&
15782 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
15783 call->called_scope = Z_OBJCE_P(call->object);
15784
15785 if (IS_CONST != IS_CONST ||
15786 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
15787 zval *object = call->object;
15788
15789 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
15790 zend_error_noreturn(E_ERROR, "Object does not support method calls");
15791 }
15792
15793 /* First, locate the function. */
15794 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
15795 if (UNEXPECTED(call->fbc == NULL)) {
15796 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
15797 }
15798 if (IS_CONST == IS_CONST &&
15799 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
15800 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
15801 EXPECTED(call->object == object)) {
15802 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
15803 }
15804 }
15805 } else {
15806 if (UNEXPECTED(EG(exception) != NULL)) {
15807
15808 HANDLE_EXCEPTION();
15809 }
15810 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
15811 }
15812
15813 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
15814 call->object = NULL;
15815 } else {
15816 if (!PZVAL_IS_REF(call->object)) {
15817 Z_ADDREF_P(call->object); /* For $this pointer */
15818 } else {
15819 zval *this_ptr;
15820 ALLOC_ZVAL(this_ptr);
15821 INIT_PZVAL_COPY(this_ptr, call->object);
15822 zval_copy_ctor(this_ptr);
15823 call->object = this_ptr;
15824 }
15825 }
15826
15827 call->num_additional_args = 0;
15828 call->is_ctor_call = 0;
15829 EX(call) = call;
15830
15831 zval_ptr_dtor_nogc(&free_op1.var);
15832
15833 CHECK_EXCEPTION();
15834 ZEND_VM_NEXT_OPCODE();
15835 }
15836
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15837 static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15838 {
15839 USE_OPLINE
15840 zval *function_name;
15841 zend_class_entry *ce;
15842 call_slot *call = EX(call_slots) + opline->result.num;
15843
15844 SAVE_OPLINE();
15845
15846 if (IS_VAR == IS_CONST) {
15847 /* no function found. try a static method in class */
15848 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
15849 ce = CACHED_PTR(opline->op1.literal->cache_slot);
15850 } else {
15851 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
15852 if (UNEXPECTED(EG(exception) != NULL)) {
15853 HANDLE_EXCEPTION();
15854 }
15855 if (UNEXPECTED(ce == NULL)) {
15856 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
15857 }
15858 CACHE_PTR(opline->op1.literal->cache_slot, ce);
15859 }
15860 call->called_scope = ce;
15861 } else {
15862 ce = EX_T(opline->op1.var).class_entry;
15863
15864 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
15865 call->called_scope = EG(called_scope);
15866 } else {
15867 call->called_scope = ce;
15868 }
15869 }
15870
15871 if (IS_VAR == IS_CONST &&
15872 IS_CONST == IS_CONST &&
15873 CACHED_PTR(opline->op2.literal->cache_slot)) {
15874 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
15875 } else if (IS_VAR != IS_CONST &&
15876 IS_CONST == IS_CONST &&
15877 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
15878 /* do nothing */
15879 } else if (IS_CONST != IS_UNUSED) {
15880 char *function_name_strval = NULL;
15881 int function_name_strlen = 0;
15882
15883
15884 if (IS_CONST == IS_CONST) {
15885 function_name_strval = Z_STRVAL_P(opline->op2.zv);
15886 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
15887 } else {
15888 function_name = opline->op2.zv;
15889
15890 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
15891 if (UNEXPECTED(EG(exception) != NULL)) {
15892 HANDLE_EXCEPTION();
15893 }
15894 zend_error_noreturn(E_ERROR, "Function name must be a string");
15895 } else {
15896 function_name_strval = Z_STRVAL_P(function_name);
15897 function_name_strlen = Z_STRLEN_P(function_name);
15898 }
15899 }
15900
15901 if (function_name_strval) {
15902 if (ce->get_static_method) {
15903 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
15904 } else {
15905 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
15906 }
15907 if (UNEXPECTED(call->fbc == NULL)) {
15908 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
15909 }
15910 if (IS_CONST == IS_CONST &&
15911 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
15912 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
15913 if (IS_VAR == IS_CONST) {
15914 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
15915 } else {
15916 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
15917 }
15918 }
15919 }
15920 if (IS_CONST != IS_CONST) {
15921
15922 }
15923 } else {
15924 if (UNEXPECTED(ce->constructor == NULL)) {
15925 zend_error_noreturn(E_ERROR, "Cannot call constructor");
15926 }
15927 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
15928 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
15929 }
15930 call->fbc = ce->constructor;
15931 }
15932
15933 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
15934 call->object = NULL;
15935 } else {
15936 if (EG(This) &&
15937 Z_OBJ_HT_P(EG(This))->get_class_entry &&
15938 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
15939 /* We are calling method of the other (incompatible) class,
15940 but passing $this. This is done for compatibility with php-4. */
15941 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
15942 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
15943 } else {
15944 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
15945 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
15946 }
15947 }
15948 if ((call->object = EG(This))) {
15949 Z_ADDREF_P(call->object);
15950 call->called_scope = Z_OBJCE_P(call->object);
15951 }
15952 }
15953
15954 call->num_additional_args = 0;
15955 call->is_ctor_call = 0;
15956 EX(call) = call;
15957
15958 CHECK_EXCEPTION();
15959 ZEND_VM_NEXT_OPCODE();
15960 }
15961
ZEND_CASE_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15962 static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15963 {
15964 USE_OPLINE
15965 zend_free_op free_op1;
15966
15967 SAVE_OPLINE();
15968 is_equal_function(&EX_T(opline->result.var).tmp_var,
15969 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
15970 opline->op2.zv TSRMLS_CC);
15971
15972 CHECK_EXCEPTION();
15973 ZEND_VM_NEXT_OPCODE();
15974 }
15975
ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15976 static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15977 {
15978 USE_OPLINE
15979
15980 SAVE_OPLINE();
15981 if (IS_VAR == IS_UNUSED) {
15982 zend_constant *c;
15983 zval *retval;
15984
15985 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
15986 c = CACHED_PTR(opline->op2.literal->cache_slot);
15987 } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
15988 if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
15989 char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
15990 if(!actual) {
15991 actual = Z_STRVAL_P(opline->op2.zv);
15992 } else {
15993 actual++;
15994 }
15995 /* non-qualified constant - allow text substitution */
15996 zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
15997 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
15998 CHECK_EXCEPTION();
15999 ZEND_VM_NEXT_OPCODE();
16000 } else {
16001 zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
16002 }
16003 } else {
16004 CACHE_PTR(opline->op2.literal->cache_slot, c);
16005 }
16006 retval = &EX_T(opline->result.var).tmp_var;
16007 ZVAL_COPY_VALUE(retval, &c->value);
16008 zval_copy_ctor(retval);
16009 } else {
16010 /* class constant */
16011 zend_class_entry *ce;
16012 zval **value;
16013
16014 if (IS_VAR == IS_CONST) {
16015 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
16016 value = CACHED_PTR(opline->op2.literal->cache_slot);
16017 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
16018 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
16019 goto constant_fetch_end;
16020 } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
16021 ce = CACHED_PTR(opline->op1.literal->cache_slot);
16022 } else {
16023 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
16024 if (UNEXPECTED(EG(exception) != NULL)) {
16025 HANDLE_EXCEPTION();
16026 }
16027 if (UNEXPECTED(ce == NULL)) {
16028 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
16029 }
16030 CACHE_PTR(opline->op1.literal->cache_slot, ce);
16031 }
16032 } else {
16033 ce = EX_T(opline->op1.var).class_entry;
16034 if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
16035 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
16036 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
16037 goto constant_fetch_end;
16038 }
16039 }
16040
16041 if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) {
16042 if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
16043 zend_class_entry *old_scope = EG(scope);
16044
16045 EG(scope) = ce;
16046 zval_update_constant(value, 1 TSRMLS_CC);
16047 EG(scope) = old_scope;
16048 }
16049 if (IS_VAR == IS_CONST) {
16050 CACHE_PTR(opline->op2.literal->cache_slot, value);
16051 } else {
16052 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
16053 }
16054 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
16055 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
16056 } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
16057 /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
16058 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
16059 } else {
16060 zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
16061 }
16062 }
16063 constant_fetch_end:
16064 CHECK_EXCEPTION();
16065 ZEND_VM_NEXT_OPCODE();
16066 }
16067
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16068 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16069 {
16070 USE_OPLINE
16071 zend_free_op free_op1;
16072 zval *expr_ptr;
16073
16074 SAVE_OPLINE();
16075 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
16076 zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16077
16078 if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
16079 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
16080 }
16081 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
16082 expr_ptr = *expr_ptr_ptr;
16083 Z_ADDREF_P(expr_ptr);
16084 } else {
16085 expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16086 if (0) { /* temporary variable */
16087 zval *new_expr;
16088
16089 ALLOC_ZVAL(new_expr);
16090 INIT_PZVAL_COPY(new_expr, expr_ptr);
16091 expr_ptr = new_expr;
16092 } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
16093 zval *new_expr;
16094
16095 ALLOC_ZVAL(new_expr);
16096 INIT_PZVAL_COPY(new_expr, expr_ptr);
16097 expr_ptr = new_expr;
16098 zendi_zval_copy_ctor(*expr_ptr);
16099 zval_ptr_dtor_nogc(&free_op1.var);
16100 } else if (IS_VAR == IS_CV) {
16101 Z_ADDREF_P(expr_ptr);
16102 }
16103 }
16104
16105 if (IS_CONST != IS_UNUSED) {
16106
16107 zval *offset = opline->op2.zv;
16108 ulong hval;
16109
16110 switch (Z_TYPE_P(offset)) {
16111 case IS_DOUBLE:
16112 hval = zend_dval_to_lval(Z_DVAL_P(offset));
16113 goto num_index;
16114 case IS_LONG:
16115 case IS_BOOL:
16116 hval = Z_LVAL_P(offset);
16117 num_index:
16118 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
16119 break;
16120 case IS_STRING:
16121 if (IS_CONST == IS_CONST) {
16122 hval = Z_HASH_P(offset);
16123 } else {
16124 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
16125 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
16126 }
16127 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
16128 break;
16129 case IS_NULL:
16130 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
16131 break;
16132 default:
16133 zend_error(E_WARNING, "Illegal offset type");
16134 zval_ptr_dtor(&expr_ptr);
16135 /* do nothing */
16136 break;
16137 }
16138
16139 } else {
16140 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
16141 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
16142 zval_ptr_dtor(&expr_ptr);
16143 }
16144 }
16145 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
16146 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
16147 }
16148 CHECK_EXCEPTION();
16149 ZEND_VM_NEXT_OPCODE();
16150 }
16151
ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16152 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16153 {
16154 USE_OPLINE
16155
16156 array_init(&EX_T(opline->result.var).tmp_var);
16157 if (IS_VAR == IS_UNUSED) {
16158 ZEND_VM_NEXT_OPCODE();
16159 #if 0 || IS_VAR != IS_UNUSED
16160 } else {
16161 return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16162 #endif
16163 }
16164 }
16165
ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16166 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16167 {
16168 USE_OPLINE
16169 zval tmp, *varname;
16170 HashTable *target_symbol_table;
16171 zend_free_op free_op1;
16172
16173 SAVE_OPLINE();
16174 if (IS_VAR == IS_CV &&
16175 IS_CONST == IS_UNUSED &&
16176 (opline->extended_value & ZEND_QUICK_SET)) {
16177 if (EG(active_symbol_table)) {
16178 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
16179
16180 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
16181 EX_CV(opline->op1.var) = NULL;
16182 } else if (EX_CV(opline->op1.var)) {
16183 zval_ptr_dtor(EX_CV(opline->op1.var));
16184 EX_CV(opline->op1.var) = NULL;
16185 }
16186 CHECK_EXCEPTION();
16187 ZEND_VM_NEXT_OPCODE();
16188 }
16189
16190 varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16191
16192 if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
16193 ZVAL_COPY_VALUE(&tmp, varname);
16194 zval_copy_ctor(&tmp);
16195 convert_to_string(&tmp);
16196 varname = &tmp;
16197 } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
16198 Z_ADDREF_P(varname);
16199 }
16200
16201 if (IS_CONST != IS_UNUSED) {
16202 zend_class_entry *ce;
16203
16204 if (IS_CONST == IS_CONST) {
16205 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
16206 ce = CACHED_PTR(opline->op2.literal->cache_slot);
16207 } else {
16208 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
16209 if (UNEXPECTED(EG(exception) != NULL)) {
16210 if (IS_VAR != IS_CONST && varname == &tmp) {
16211 zval_dtor(&tmp);
16212 } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
16213 zval_ptr_dtor(&varname);
16214 }
16215 zval_ptr_dtor_nogc(&free_op1.var);
16216 HANDLE_EXCEPTION();
16217 }
16218 if (UNEXPECTED(ce == NULL)) {
16219 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
16220 }
16221 CACHE_PTR(opline->op2.literal->cache_slot, ce);
16222 }
16223 } else {
16224 ce = EX_T(opline->op2.var).class_entry;
16225 }
16226 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
16227 } else {
16228 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
16229
16230 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
16231 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
16232 }
16233
16234 if (IS_VAR != IS_CONST && varname == &tmp) {
16235 zval_dtor(&tmp);
16236 } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
16237 zval_ptr_dtor(&varname);
16238 }
16239 zval_ptr_dtor_nogc(&free_op1.var);
16240 CHECK_EXCEPTION();
16241 ZEND_VM_NEXT_OPCODE();
16242 }
16243
ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16244 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16245 {
16246 USE_OPLINE
16247 zend_free_op free_op1;
16248 zval **container;
16249 zval *offset;
16250 ulong hval;
16251
16252 SAVE_OPLINE();
16253 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16254 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
16255 SEPARATE_ZVAL_IF_NOT_REF(container);
16256 }
16257 offset = opline->op2.zv;
16258
16259 if (IS_VAR != IS_VAR || container) {
16260 switch (Z_TYPE_PP(container)) {
16261 case IS_ARRAY: {
16262 HashTable *ht = Z_ARRVAL_PP(container);
16263
16264 switch (Z_TYPE_P(offset)) {
16265 case IS_DOUBLE:
16266 hval = zend_dval_to_lval(Z_DVAL_P(offset));
16267 zend_hash_index_del(ht, hval);
16268 break;
16269 case IS_RESOURCE:
16270 case IS_BOOL:
16271 case IS_LONG:
16272 hval = Z_LVAL_P(offset);
16273 zend_hash_index_del(ht, hval);
16274 break;
16275 case IS_STRING:
16276 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
16277 Z_ADDREF_P(offset);
16278 }
16279 if (IS_CONST == IS_CONST) {
16280 hval = Z_HASH_P(offset);
16281 } else {
16282 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
16283 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
16284 }
16285 if (ht == &EG(symbol_table)) {
16286 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
16287 } else {
16288 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
16289 }
16290 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
16291 zval_ptr_dtor(&offset);
16292 }
16293 break;
16294 num_index_dim:
16295 zend_hash_index_del(ht, hval);
16296 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
16297 zval_ptr_dtor(&offset);
16298 }
16299 break;
16300 case IS_NULL:
16301 zend_hash_del(ht, "", sizeof(""));
16302 break;
16303 default:
16304 zend_error(E_WARNING, "Illegal offset type in unset");
16305 break;
16306 }
16307
16308 break;
16309 }
16310 case IS_OBJECT:
16311 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
16312 zend_error_noreturn(E_ERROR, "Cannot use object as array");
16313 }
16314 if (0) {
16315 MAKE_REAL_ZVAL_PTR(offset);
16316 }
16317 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
16318 if (0) {
16319 zval_ptr_dtor(&offset);
16320 } else {
16321
16322 }
16323 break;
16324 case IS_STRING:
16325 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
16326 ZEND_VM_CONTINUE(); /* bailed out before */
16327 default:
16328
16329 break;
16330 }
16331 } else {
16332
16333 }
16334 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
16335
16336 CHECK_EXCEPTION();
16337 ZEND_VM_NEXT_OPCODE();
16338 }
16339
ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16340 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16341 {
16342 USE_OPLINE
16343 zend_free_op free_op1;
16344 zval **container;
16345 zval *offset;
16346
16347 SAVE_OPLINE();
16348 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16349 offset = opline->op2.zv;
16350
16351 if (IS_VAR != IS_VAR || container) {
16352 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
16353 SEPARATE_ZVAL_IF_NOT_REF(container);
16354 }
16355 if (Z_TYPE_PP(container) == IS_OBJECT) {
16356 if (0) {
16357 MAKE_REAL_ZVAL_PTR(offset);
16358 }
16359 if (Z_OBJ_HT_P(*container)->unset_property) {
16360 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
16361 } else {
16362 zend_error(E_NOTICE, "Trying to unset property of non-object");
16363 }
16364 if (0) {
16365 zval_ptr_dtor(&offset);
16366 } else {
16367
16368 }
16369 } else {
16370
16371 }
16372 } else {
16373
16374 }
16375 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
16376
16377 CHECK_EXCEPTION();
16378 ZEND_VM_NEXT_OPCODE();
16379 }
16380
ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16381 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16382 {
16383 USE_OPLINE
16384 zval **value;
16385 zend_bool isset = 1;
16386
16387 SAVE_OPLINE();
16388 if (IS_VAR == IS_CV &&
16389 IS_CONST == IS_UNUSED &&
16390 (opline->extended_value & ZEND_QUICK_SET)) {
16391 if (EX_CV(opline->op1.var)) {
16392 value = EX_CV(opline->op1.var);
16393 } else if (EG(active_symbol_table)) {
16394 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
16395
16396 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
16397 isset = 0;
16398 }
16399 } else {
16400 isset = 0;
16401 }
16402 } else {
16403 HashTable *target_symbol_table;
16404 zend_free_op free_op1;
16405 zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16406
16407 if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
16408 ZVAL_COPY_VALUE(&tmp, varname);
16409 zval_copy_ctor(&tmp);
16410 convert_to_string(&tmp);
16411 varname = &tmp;
16412 }
16413
16414 if (IS_CONST != IS_UNUSED) {
16415 zend_class_entry *ce;
16416
16417 if (IS_CONST == IS_CONST) {
16418 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
16419 ce = CACHED_PTR(opline->op2.literal->cache_slot);
16420 } else {
16421 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
16422 if (UNEXPECTED(ce == NULL)) {
16423 CHECK_EXCEPTION();
16424 ZEND_VM_NEXT_OPCODE();
16425 }
16426 CACHE_PTR(opline->op2.literal->cache_slot, ce);
16427 }
16428 } else {
16429 ce = EX_T(opline->op2.var).class_entry;
16430 }
16431 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
16432 if (!value) {
16433 isset = 0;
16434 }
16435 } else {
16436 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
16437 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
16438 isset = 0;
16439 }
16440 }
16441
16442 if (IS_VAR != IS_CONST && varname == &tmp) {
16443 zval_dtor(&tmp);
16444 }
16445 zval_ptr_dtor_nogc(&free_op1.var);
16446 }
16447
16448 if (opline->extended_value & ZEND_ISSET) {
16449 if (isset && Z_TYPE_PP(value) != IS_NULL) {
16450 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
16451 } else {
16452 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
16453 }
16454 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
16455 if (!isset || !i_zend_is_true(*value)) {
16456 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
16457 } else {
16458 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
16459 }
16460 }
16461
16462 CHECK_EXCEPTION();
16463 ZEND_VM_NEXT_OPCODE();
16464 }
16465
zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)16466 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
16467 {
16468 USE_OPLINE
16469 zend_free_op free_op1;
16470 zval *container;
16471 zval **value = NULL;
16472 int result = 0;
16473 ulong hval;
16474 zval *offset;
16475
16476 SAVE_OPLINE();
16477 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16478 offset = opline->op2.zv;
16479
16480 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
16481 HashTable *ht;
16482 int isset = 0;
16483
16484 ht = Z_ARRVAL_P(container);
16485
16486 switch (Z_TYPE_P(offset)) {
16487 case IS_DOUBLE:
16488 hval = zend_dval_to_lval(Z_DVAL_P(offset));
16489 goto num_index_prop;
16490 case IS_RESOURCE:
16491 case IS_BOOL:
16492 case IS_LONG:
16493 hval = Z_LVAL_P(offset);
16494 num_index_prop:
16495 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
16496 isset = 1;
16497 }
16498 break;
16499 case IS_STRING:
16500 if (IS_CONST == IS_CONST) {
16501 hval = Z_HASH_P(offset);
16502 } else {
16503 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
16504 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
16505 }
16506 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
16507 isset = 1;
16508 }
16509 break;
16510 case IS_NULL:
16511 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
16512 isset = 1;
16513 }
16514 break;
16515 default:
16516 zend_error(E_WARNING, "Illegal offset type in isset or empty");
16517 break;
16518 }
16519
16520 if (opline->extended_value & ZEND_ISSET) {
16521 if (isset && Z_TYPE_PP(value) == IS_NULL) {
16522 result = 0;
16523 } else {
16524 result = isset;
16525 }
16526 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
16527 if (!isset || !i_zend_is_true(*value)) {
16528 result = 0;
16529 } else {
16530 result = 1;
16531 }
16532 }
16533
16534 } else if (Z_TYPE_P(container) == IS_OBJECT) {
16535 if (0) {
16536 MAKE_REAL_ZVAL_PTR(offset);
16537 }
16538 if (prop_dim) {
16539 if (Z_OBJ_HT_P(container)->has_property) {
16540 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
16541 } else {
16542 zend_error(E_NOTICE, "Trying to check property of non-object");
16543 result = 0;
16544 }
16545 } else {
16546 if (Z_OBJ_HT_P(container)->has_dimension) {
16547 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
16548 } else {
16549 zend_error(E_NOTICE, "Trying to check element of non-array");
16550 result = 0;
16551 }
16552 }
16553 if (0) {
16554 zval_ptr_dtor(&offset);
16555 } else {
16556
16557 }
16558 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
16559 zval tmp;
16560
16561 if (Z_TYPE_P(offset) != IS_LONG) {
16562 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
16563 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
16564 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
16565 ZVAL_COPY_VALUE(&tmp, offset);
16566 zval_copy_ctor(&tmp);
16567 convert_to_long(&tmp);
16568 offset = &tmp;
16569 } else {
16570 /* can not be converted to proper offset, return "not set" */
16571 result = 0;
16572 }
16573 }
16574 if (Z_TYPE_P(offset) == IS_LONG) {
16575 if (opline->extended_value & ZEND_ISSET) {
16576 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
16577 result = 1;
16578 }
16579 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
16580 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
16581 result = 1;
16582 }
16583 }
16584 }
16585
16586 } else {
16587
16588 }
16589
16590 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
16591 if (opline->extended_value & ZEND_ISSET) {
16592 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
16593 } else {
16594 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
16595 }
16596
16597 zval_ptr_dtor_nogc(&free_op1.var);
16598
16599 CHECK_EXCEPTION();
16600 ZEND_VM_NEXT_OPCODE();
16601 }
16602
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16603 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16604 {
16605 return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16606 }
16607
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16608 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16609 {
16610 return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16611 }
16612
ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16613 static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16614 {
16615 USE_OPLINE
16616
16617 /* The generator object is stored in return_value_ptr_ptr */
16618 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
16619
16620 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
16621 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
16622 }
16623
16624 /* Destroy the previously yielded value */
16625 if (generator->value) {
16626 zval_ptr_dtor(&generator->value);
16627 }
16628
16629 /* Destroy the previously yielded key */
16630 if (generator->key) {
16631 zval_ptr_dtor(&generator->key);
16632 }
16633
16634 /* Set the new yielded value */
16635 if (IS_VAR != IS_UNUSED) {
16636 zend_free_op free_op1;
16637
16638 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
16639 /* Constants and temporary variables aren't yieldable by reference,
16640 * but we still allow them with a notice. */
16641 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
16642 zval *value, *copy;
16643
16644 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
16645
16646 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16647 ALLOC_ZVAL(copy);
16648 INIT_PZVAL_COPY(copy, value);
16649
16650 /* Temporary variables don't need ctor copying */
16651 if (!0) {
16652 zval_copy_ctor(copy);
16653 }
16654
16655 generator->value = copy;
16656 } else {
16657 zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16658
16659 if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
16660 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
16661 }
16662
16663 /* If a function call result is yielded and the function did
16664 * not return by reference we throw a notice. */
16665 if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
16666 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
16667 && EX_T(opline->op1.var).var.fcall_returned_reference)
16668 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
16669 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
16670
16671 Z_ADDREF_PP(value_ptr);
16672 generator->value = *value_ptr;
16673 } else {
16674 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
16675 Z_ADDREF_PP(value_ptr);
16676 generator->value = *value_ptr;
16677 }
16678
16679 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
16680 }
16681 } else {
16682 zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16683
16684 /* Consts, temporary variables and references need copying */
16685 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
16686 || PZVAL_IS_REF(value)
16687 ) {
16688 zval *copy;
16689
16690 ALLOC_ZVAL(copy);
16691 INIT_PZVAL_COPY(copy, value);
16692
16693 /* Temporary variables don't need ctor copying */
16694 if (!0) {
16695 zval_copy_ctor(copy);
16696 }
16697
16698 generator->value = copy;
16699 zval_ptr_dtor_nogc(&free_op1.var);
16700 } else {
16701 if (IS_VAR == IS_CV) {
16702 Z_ADDREF_P(value);
16703 }
16704 generator->value = value;
16705 }
16706 }
16707 } else {
16708 /* If no value was specified yield null */
16709 Z_ADDREF(EG(uninitialized_zval));
16710 generator->value = &EG(uninitialized_zval);
16711 }
16712
16713 /* Set the new yielded key */
16714 if (IS_CONST != IS_UNUSED) {
16715
16716 zval *key = opline->op2.zv;
16717
16718 /* Consts, temporary variables and references need copying */
16719 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
16720 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
16721 ) {
16722 zval *copy;
16723
16724 ALLOC_ZVAL(copy);
16725 INIT_PZVAL_COPY(copy, key);
16726
16727 /* Temporary variables don't need ctor copying */
16728 if (!0) {
16729 zval_copy_ctor(copy);
16730 }
16731
16732 generator->key = copy;
16733 } else {
16734 Z_ADDREF_P(key);
16735 generator->key = key;
16736 }
16737
16738 if (Z_TYPE_P(generator->key) == IS_LONG
16739 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
16740 ) {
16741 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
16742 }
16743
16744 } else {
16745 /* If no key was specified we use auto-increment keys */
16746 generator->largest_used_integer_key++;
16747
16748 ALLOC_INIT_ZVAL(generator->key);
16749 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
16750 }
16751
16752 if (RETURN_VALUE_USED(opline)) {
16753 /* If the return value of yield is used set the send
16754 * target and initialize it to NULL */
16755 generator->send_target = &EX_T(opline->result.var).var.ptr;
16756 Z_ADDREF(EG(uninitialized_zval));
16757 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
16758 } else {
16759 generator->send_target = NULL;
16760 }
16761
16762 /* We increment to the next op, so we are at the correct position when the
16763 * generator is resumed. */
16764 ZEND_VM_INC_OPCODE();
16765
16766 /* The GOTO VM uses a local opline variable. We need to set the opline
16767 * variable in execute_data so we don't resume at an old position. */
16768 SAVE_OPLINE();
16769
16770 ZEND_VM_RETURN();
16771 }
16772
ZEND_POW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16773 static int ZEND_FASTCALL ZEND_POW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16774 {
16775 USE_OPLINE
16776 zend_free_op free_op1;
16777
16778 SAVE_OPLINE();
16779 pow_function(&EX_T(opline->result.var).tmp_var,
16780 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16781 opline->op2.zv TSRMLS_CC);
16782 zval_ptr_dtor_nogc(&free_op1.var);
16783
16784 CHECK_EXCEPTION();
16785 ZEND_VM_NEXT_OPCODE();
16786 }
16787
ZEND_ASSIGN_POW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16788 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16789 {
16790 return zend_binary_assign_op_helper_SPEC_VAR_CONST(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16791 }
16792
ZEND_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16793 static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16794 {
16795 USE_OPLINE
16796 zend_free_op free_op1, free_op2;
16797
16798 SAVE_OPLINE();
16799 fast_add_function(&EX_T(opline->result.var).tmp_var,
16800 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16801 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16802 zval_ptr_dtor_nogc(&free_op1.var);
16803 zval_dtor(free_op2.var);
16804 CHECK_EXCEPTION();
16805 ZEND_VM_NEXT_OPCODE();
16806 }
16807
ZEND_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16808 static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16809 {
16810 USE_OPLINE
16811 zend_free_op free_op1, free_op2;
16812
16813 SAVE_OPLINE();
16814 fast_sub_function(&EX_T(opline->result.var).tmp_var,
16815 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16816 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16817 zval_ptr_dtor_nogc(&free_op1.var);
16818 zval_dtor(free_op2.var);
16819 CHECK_EXCEPTION();
16820 ZEND_VM_NEXT_OPCODE();
16821 }
16822
ZEND_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16823 static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16824 {
16825 USE_OPLINE
16826 zend_free_op free_op1, free_op2;
16827
16828 SAVE_OPLINE();
16829 fast_mul_function(&EX_T(opline->result.var).tmp_var,
16830 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16831 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16832 zval_ptr_dtor_nogc(&free_op1.var);
16833 zval_dtor(free_op2.var);
16834 CHECK_EXCEPTION();
16835 ZEND_VM_NEXT_OPCODE();
16836 }
16837
ZEND_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16838 static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16839 {
16840 USE_OPLINE
16841 zend_free_op free_op1, free_op2;
16842
16843 SAVE_OPLINE();
16844 fast_div_function(&EX_T(opline->result.var).tmp_var,
16845 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16846 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16847 zval_ptr_dtor_nogc(&free_op1.var);
16848 zval_dtor(free_op2.var);
16849 CHECK_EXCEPTION();
16850 ZEND_VM_NEXT_OPCODE();
16851 }
16852
ZEND_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16853 static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16854 {
16855 USE_OPLINE
16856 zend_free_op free_op1, free_op2;
16857
16858 SAVE_OPLINE();
16859 fast_mod_function(&EX_T(opline->result.var).tmp_var,
16860 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16861 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16862 zval_ptr_dtor_nogc(&free_op1.var);
16863 zval_dtor(free_op2.var);
16864 CHECK_EXCEPTION();
16865 ZEND_VM_NEXT_OPCODE();
16866 }
16867
ZEND_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16868 static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16869 {
16870 USE_OPLINE
16871 zend_free_op free_op1, free_op2;
16872
16873 SAVE_OPLINE();
16874 shift_left_function(&EX_T(opline->result.var).tmp_var,
16875 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16876 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16877 zval_ptr_dtor_nogc(&free_op1.var);
16878 zval_dtor(free_op2.var);
16879 CHECK_EXCEPTION();
16880 ZEND_VM_NEXT_OPCODE();
16881 }
16882
ZEND_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16883 static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16884 {
16885 USE_OPLINE
16886 zend_free_op free_op1, free_op2;
16887
16888 SAVE_OPLINE();
16889 shift_right_function(&EX_T(opline->result.var).tmp_var,
16890 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16891 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16892 zval_ptr_dtor_nogc(&free_op1.var);
16893 zval_dtor(free_op2.var);
16894 CHECK_EXCEPTION();
16895 ZEND_VM_NEXT_OPCODE();
16896 }
16897
ZEND_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16898 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16899 {
16900 USE_OPLINE
16901 zend_free_op free_op1, free_op2;
16902
16903 SAVE_OPLINE();
16904 concat_function(&EX_T(opline->result.var).tmp_var,
16905 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16906 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16907 zval_ptr_dtor_nogc(&free_op1.var);
16908 zval_dtor(free_op2.var);
16909 CHECK_EXCEPTION();
16910 ZEND_VM_NEXT_OPCODE();
16911 }
16912
ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16913 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16914 {
16915 USE_OPLINE
16916 zend_free_op free_op1, free_op2;
16917
16918 SAVE_OPLINE();
16919 is_identical_function(&EX_T(opline->result.var).tmp_var,
16920 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16921 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16922 zval_ptr_dtor_nogc(&free_op1.var);
16923 zval_dtor(free_op2.var);
16924 CHECK_EXCEPTION();
16925 ZEND_VM_NEXT_OPCODE();
16926 }
16927
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16928 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16929 {
16930 USE_OPLINE
16931 zend_free_op free_op1, free_op2;
16932 zval *result = &EX_T(opline->result.var).tmp_var;
16933
16934 SAVE_OPLINE();
16935 is_identical_function(result,
16936 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16937 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16938 Z_LVAL_P(result) = !Z_LVAL_P(result);
16939 zval_ptr_dtor_nogc(&free_op1.var);
16940 zval_dtor(free_op2.var);
16941 CHECK_EXCEPTION();
16942 ZEND_VM_NEXT_OPCODE();
16943 }
16944
ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16945 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16946 {
16947 USE_OPLINE
16948 zend_free_op free_op1, free_op2;
16949 zval *result = &EX_T(opline->result.var).tmp_var;
16950
16951 SAVE_OPLINE();
16952 ZVAL_BOOL(result, fast_equal_function(result,
16953 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16954 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
16955 zval_ptr_dtor_nogc(&free_op1.var);
16956 zval_dtor(free_op2.var);
16957 CHECK_EXCEPTION();
16958 ZEND_VM_NEXT_OPCODE();
16959 }
16960
ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16961 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16962 {
16963 USE_OPLINE
16964 zend_free_op free_op1, free_op2;
16965 zval *result = &EX_T(opline->result.var).tmp_var;
16966
16967 SAVE_OPLINE();
16968 ZVAL_BOOL(result, fast_not_equal_function(result,
16969 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16970 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
16971 zval_ptr_dtor_nogc(&free_op1.var);
16972 zval_dtor(free_op2.var);
16973 CHECK_EXCEPTION();
16974 ZEND_VM_NEXT_OPCODE();
16975 }
16976
ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16977 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16978 {
16979 USE_OPLINE
16980 zend_free_op free_op1, free_op2;
16981 zval *result = &EX_T(opline->result.var).tmp_var;
16982
16983 SAVE_OPLINE();
16984 ZVAL_BOOL(result, fast_is_smaller_function(result,
16985 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16986 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
16987 zval_ptr_dtor_nogc(&free_op1.var);
16988 zval_dtor(free_op2.var);
16989 CHECK_EXCEPTION();
16990 ZEND_VM_NEXT_OPCODE();
16991 }
16992
ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16993 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16994 {
16995 USE_OPLINE
16996 zend_free_op free_op1, free_op2;
16997 zval *result = &EX_T(opline->result.var).tmp_var;
16998
16999 SAVE_OPLINE();
17000 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
17001 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
17002 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
17003 zval_ptr_dtor_nogc(&free_op1.var);
17004 zval_dtor(free_op2.var);
17005 CHECK_EXCEPTION();
17006 ZEND_VM_NEXT_OPCODE();
17007 }
17008
ZEND_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17009 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17010 {
17011 USE_OPLINE
17012 zend_free_op free_op1, free_op2;
17013
17014 SAVE_OPLINE();
17015 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
17016 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
17017 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
17018 zval_ptr_dtor_nogc(&free_op1.var);
17019 zval_dtor(free_op2.var);
17020 CHECK_EXCEPTION();
17021 ZEND_VM_NEXT_OPCODE();
17022 }
17023
ZEND_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17024 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17025 {
17026 USE_OPLINE
17027 zend_free_op free_op1, free_op2;
17028
17029 SAVE_OPLINE();
17030 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
17031 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
17032 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
17033 zval_ptr_dtor_nogc(&free_op1.var);
17034 zval_dtor(free_op2.var);
17035 CHECK_EXCEPTION();
17036 ZEND_VM_NEXT_OPCODE();
17037 }
17038
ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17039 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17040 {
17041 USE_OPLINE
17042 zend_free_op free_op1, free_op2;
17043
17044 SAVE_OPLINE();
17045 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
17046 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
17047 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
17048 zval_ptr_dtor_nogc(&free_op1.var);
17049 zval_dtor(free_op2.var);
17050 CHECK_EXCEPTION();
17051 ZEND_VM_NEXT_OPCODE();
17052 }
17053
ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17054 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17055 {
17056 USE_OPLINE
17057 zend_free_op free_op1, free_op2;
17058
17059 SAVE_OPLINE();
17060 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
17061 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
17062 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
17063 zval_ptr_dtor_nogc(&free_op1.var);
17064 zval_dtor(free_op2.var);
17065 CHECK_EXCEPTION();
17066 ZEND_VM_NEXT_OPCODE();
17067 }
17068
zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)17069 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
17070 {
17071 USE_OPLINE
17072 zend_free_op free_op1, free_op2, free_op_data1;
17073 zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17074 zval *object;
17075 zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17076 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
17077 int have_get_ptr = 0;
17078
17079 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
17080 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17081 }
17082
17083 make_real_object(object_ptr TSRMLS_CC);
17084 object = *object_ptr;
17085
17086 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
17087 zend_error(E_WARNING, "Attempt to assign property of non-object");
17088 zval_dtor(free_op2.var);
17089 FREE_OP(free_op_data1);
17090
17091 if (RETURN_VALUE_USED(opline)) {
17092 PZVAL_LOCK(&EG(uninitialized_zval));
17093 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17094 }
17095 } else {
17096 /* here we are sure we are dealing with an object */
17097 if (1) {
17098 MAKE_REAL_ZVAL_PTR(property);
17099 }
17100
17101 /* here property is a string */
17102 if (opline->extended_value == ZEND_ASSIGN_OBJ
17103 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17104 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17105 if (zptr != NULL) { /* NULL means no success in getting PTR */
17106 have_get_ptr = 1;
17107 if (UNEXPECTED(*zptr == &EG(error_zval))) {
17108 if (RETURN_VALUE_USED(opline)) {
17109 PZVAL_LOCK(&EG(uninitialized_zval));
17110 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17111 }
17112 } else {
17113 SEPARATE_ZVAL_IF_NOT_REF(zptr);
17114
17115 binary_op(*zptr, *zptr, value TSRMLS_CC);
17116 if (RETURN_VALUE_USED(opline)) {
17117 PZVAL_LOCK(*zptr);
17118 EX_T(opline->result.var).var.ptr = *zptr;
17119 }
17120 }
17121 }
17122 }
17123
17124 if (!have_get_ptr) {
17125 zval *z = NULL;
17126
17127 Z_ADDREF_P(object);
17128 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
17129 if (Z_OBJ_HT_P(object)->read_property) {
17130 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17131 }
17132 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
17133 if (Z_OBJ_HT_P(object)->read_dimension) {
17134 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
17135 }
17136 }
17137 if (z) {
17138 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
17139 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17140
17141 if (Z_REFCOUNT_P(z) == 0) {
17142 GC_REMOVE_ZVAL_FROM_BUFFER(z);
17143 zval_dtor(z);
17144 FREE_ZVAL(z);
17145 }
17146 z = value;
17147 }
17148 Z_ADDREF_P(z);
17149 SEPARATE_ZVAL_IF_NOT_REF(&z);
17150 binary_op(z, z, value TSRMLS_CC);
17151 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
17152 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17153 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
17154 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
17155 }
17156 if (RETURN_VALUE_USED(opline)) {
17157 PZVAL_LOCK(z);
17158 EX_T(opline->result.var).var.ptr = z;
17159 }
17160 zval_ptr_dtor(&z);
17161 } else {
17162 zend_error(E_WARNING, "Attempt to assign property of non-object");
17163 if (RETURN_VALUE_USED(opline)) {
17164 PZVAL_LOCK(&EG(uninitialized_zval));
17165 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17166 }
17167 }
17168 zval_ptr_dtor(&object);
17169 }
17170
17171 if (1) {
17172 zval_ptr_dtor(&property);
17173 } else {
17174 zval_dtor(free_op2.var);
17175 }
17176 FREE_OP(free_op_data1);
17177 }
17178
17179 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17180 /* assign_obj has two opcodes! */
17181 CHECK_EXCEPTION();
17182 ZEND_VM_INC_OPCODE();
17183 ZEND_VM_NEXT_OPCODE();
17184 }
17185
zend_binary_assign_op_helper_SPEC_VAR_TMP(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)17186 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
17187 {
17188 USE_OPLINE
17189 zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
17190 zval **var_ptr;
17191 zval *value;
17192
17193 SAVE_OPLINE();
17194 switch (opline->extended_value) {
17195 case ZEND_ASSIGN_OBJ:
17196 return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17197 break;
17198 case ZEND_ASSIGN_DIM: {
17199 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17200
17201 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17202 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17203 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
17204 if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
17205 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
17206 }
17207 return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17208 } else {
17209 zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17210
17211 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
17212 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
17213 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
17214 }
17215 }
17216 break;
17217 default:
17218 value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17219 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17220 /* do nothing */
17221 break;
17222 }
17223
17224 if (UNEXPECTED(var_ptr == NULL)) {
17225 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
17226 }
17227
17228 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
17229 if (RETURN_VALUE_USED(opline)) {
17230 PZVAL_LOCK(&EG(uninitialized_zval));
17231 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17232 }
17233 zval_dtor(free_op2.var);
17234 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17235 CHECK_EXCEPTION();
17236 if (opline->extended_value == ZEND_ASSIGN_DIM) {
17237 ZEND_VM_INC_OPCODE();
17238 }
17239 ZEND_VM_NEXT_OPCODE();
17240 }
17241
17242 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
17243
17244 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
17245 && Z_OBJ_HANDLER_PP(var_ptr, get)
17246 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
17247 /* proxy object */
17248 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
17249 Z_ADDREF_P(objval);
17250 binary_op(objval, objval, value TSRMLS_CC);
17251 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
17252 zval_ptr_dtor(&objval);
17253 } else {
17254 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
17255 }
17256
17257 if (RETURN_VALUE_USED(opline)) {
17258 PZVAL_LOCK(*var_ptr);
17259 EX_T(opline->result.var).var.ptr = *var_ptr;
17260 }
17261 zval_dtor(free_op2.var);
17262
17263 if (opline->extended_value == ZEND_ASSIGN_DIM) {
17264 FREE_OP(free_op_data1);
17265 FREE_OP_VAR_PTR(free_op_data2);
17266 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17267 CHECK_EXCEPTION();
17268 ZEND_VM_INC_OPCODE();
17269 } else {
17270 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17271 CHECK_EXCEPTION();
17272 }
17273 ZEND_VM_NEXT_OPCODE();
17274 }
17275
ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17276 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17277 {
17278 return zend_binary_assign_op_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17279 }
17280
ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17281 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17282 {
17283 return zend_binary_assign_op_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17284 }
17285
ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17286 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17287 {
17288 return zend_binary_assign_op_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17289 }
17290
ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17291 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17292 {
17293 return zend_binary_assign_op_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17294 }
17295
ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17296 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17297 {
17298 return zend_binary_assign_op_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17299 }
17300
ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17301 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17302 {
17303 return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17304 }
17305
ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17306 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17307 {
17308 return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17309 }
17310
ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17311 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17312 {
17313 return zend_binary_assign_op_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17314 }
17315
ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17316 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17317 {
17318 return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17319 }
17320
ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17321 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17322 {
17323 return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17324 }
17325
ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17326 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17327 {
17328 return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17329 }
17330
zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)17331 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
17332 {
17333 USE_OPLINE
17334 zend_free_op free_op1, free_op2;
17335 zval **object_ptr;
17336 zval *object;
17337 zval *property;
17338 zval **retval;
17339 int have_get_ptr = 0;
17340
17341 SAVE_OPLINE();
17342 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17343 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17344 retval = &EX_T(opline->result.var).var.ptr;
17345
17346 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
17347 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
17348 }
17349
17350 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
17351 object = *object_ptr;
17352
17353 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
17354 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17355 zval_dtor(free_op2.var);
17356 if (RETURN_VALUE_USED(opline)) {
17357 PZVAL_LOCK(&EG(uninitialized_zval));
17358 *retval = &EG(uninitialized_zval);
17359 }
17360 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17361 CHECK_EXCEPTION();
17362 ZEND_VM_NEXT_OPCODE();
17363 }
17364
17365 /* here we are sure we are dealing with an object */
17366
17367 if (1) {
17368 MAKE_REAL_ZVAL_PTR(property);
17369 }
17370
17371 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17372 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17373 if (zptr != NULL) { /* NULL means no success in getting PTR */
17374 have_get_ptr = 1;
17375 if (UNEXPECTED(*zptr == &EG(error_zval))) {
17376 if (RETURN_VALUE_USED(opline)) {
17377 PZVAL_LOCK(&EG(uninitialized_zval));
17378 *retval = &EG(uninitialized_zval);
17379 }
17380 } else {
17381 SEPARATE_ZVAL_IF_NOT_REF(zptr);
17382
17383 incdec_op(*zptr);
17384 if (RETURN_VALUE_USED(opline)) {
17385 *retval = *zptr;
17386 PZVAL_LOCK(*retval);
17387 }
17388 }
17389 }
17390 }
17391
17392 if (!have_get_ptr) {
17393 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
17394 zval *z;
17395
17396 Z_ADDREF_P(object);
17397 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17398
17399 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
17400 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17401
17402 if (Z_REFCOUNT_P(z) == 0) {
17403 GC_REMOVE_ZVAL_FROM_BUFFER(z);
17404 zval_dtor(z);
17405 FREE_ZVAL(z);
17406 }
17407 z = value;
17408 }
17409 Z_ADDREF_P(z);
17410 SEPARATE_ZVAL_IF_NOT_REF(&z);
17411 incdec_op(z);
17412 *retval = z;
17413 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17414 zval_ptr_dtor(&object);
17415 SELECTIVE_PZVAL_LOCK(*retval, opline);
17416 zval_ptr_dtor(&z);
17417 } else {
17418 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17419 if (RETURN_VALUE_USED(opline)) {
17420 PZVAL_LOCK(&EG(uninitialized_zval));
17421 *retval = &EG(uninitialized_zval);
17422 }
17423 }
17424 }
17425
17426 if (1) {
17427 zval_ptr_dtor(&property);
17428 } else {
17429 zval_dtor(free_op2.var);
17430 }
17431 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17432 CHECK_EXCEPTION();
17433 ZEND_VM_NEXT_OPCODE();
17434 }
17435
ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17436 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17437 {
17438 return zend_pre_incdec_property_helper_SPEC_VAR_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17439 }
17440
ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17441 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17442 {
17443 return zend_pre_incdec_property_helper_SPEC_VAR_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17444 }
17445
zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)17446 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
17447 {
17448 USE_OPLINE
17449 zend_free_op free_op1, free_op2;
17450 zval **object_ptr;
17451 zval *object;
17452 zval *property;
17453 zval *retval;
17454 int have_get_ptr = 0;
17455
17456 SAVE_OPLINE();
17457 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17458 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17459 retval = &EX_T(opline->result.var).tmp_var;
17460
17461 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
17462 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
17463 }
17464
17465 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
17466 object = *object_ptr;
17467
17468 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
17469 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17470 zval_dtor(free_op2.var);
17471 ZVAL_NULL(retval);
17472 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17473 CHECK_EXCEPTION();
17474 ZEND_VM_NEXT_OPCODE();
17475 }
17476
17477 /* here we are sure we are dealing with an object */
17478
17479 if (1) {
17480 MAKE_REAL_ZVAL_PTR(property);
17481 }
17482
17483 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17484 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17485 if (zptr != NULL) { /* NULL means no success in getting PTR */
17486 have_get_ptr = 1;
17487 if (UNEXPECTED(*zptr == &EG(error_zval))) {
17488 ZVAL_NULL(retval);
17489 } else {
17490 SEPARATE_ZVAL_IF_NOT_REF(zptr);
17491
17492 ZVAL_COPY_VALUE(retval, *zptr);
17493 zendi_zval_copy_ctor(*retval);
17494
17495 incdec_op(*zptr);
17496 }
17497 }
17498 }
17499
17500 if (!have_get_ptr) {
17501 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
17502 zval *z, *z_copy;
17503
17504 Z_ADDREF_P(object);
17505 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17506 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
17507 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17508
17509 if (Z_REFCOUNT_P(z) == 0) {
17510 GC_REMOVE_ZVAL_FROM_BUFFER(z);
17511 zval_dtor(z);
17512 FREE_ZVAL(z);
17513 }
17514 z = value;
17515 }
17516 ZVAL_COPY_VALUE(retval, z);
17517 zendi_zval_copy_ctor(*retval);
17518 ALLOC_ZVAL(z_copy);
17519 INIT_PZVAL_COPY(z_copy, z);
17520 zendi_zval_copy_ctor(*z_copy);
17521 incdec_op(z_copy);
17522 Z_ADDREF_P(z);
17523 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17524 zval_ptr_dtor(&object);
17525 zval_ptr_dtor(&z_copy);
17526 zval_ptr_dtor(&z);
17527 } else {
17528 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17529 ZVAL_NULL(retval);
17530 }
17531 }
17532
17533 if (1) {
17534 zval_ptr_dtor(&property);
17535 } else {
17536 zval_dtor(free_op2.var);
17537 }
17538 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17539 CHECK_EXCEPTION();
17540 ZEND_VM_NEXT_OPCODE();
17541 }
17542
ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17543 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17544 {
17545 return zend_post_incdec_property_helper_SPEC_VAR_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17546 }
17547
ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17548 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17549 {
17550 return zend_post_incdec_property_helper_SPEC_VAR_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17551 }
17552
ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17553 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17554 {
17555 USE_OPLINE
17556 zend_free_op free_op1, free_op2;
17557 zval *container;
17558
17559 SAVE_OPLINE();
17560 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17561 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
17562 zval_dtor(free_op2.var);
17563 if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
17564 zval_ptr_dtor_nogc(&free_op1.var);
17565 }
17566 CHECK_EXCEPTION();
17567 ZEND_VM_NEXT_OPCODE();
17568 }
17569
ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17570 static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17571 {
17572 USE_OPLINE
17573 zend_free_op free_op1, free_op2;
17574 zval **container;
17575
17576 SAVE_OPLINE();
17577 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17578
17579 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17580 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17581 }
17582 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
17583 zval_dtor(free_op2.var);
17584 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17585 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17586 }
17587 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17588
17589 /* We are going to assign the result by reference */
17590 if (UNEXPECTED(opline->extended_value != 0)) {
17591 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
17592
17593 if (retval_ptr) {
17594 Z_DELREF_PP(retval_ptr);
17595 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
17596 Z_ADDREF_PP(retval_ptr);
17597 }
17598 }
17599
17600 CHECK_EXCEPTION();
17601 ZEND_VM_NEXT_OPCODE();
17602 }
17603
ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17604 static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17605 {
17606 USE_OPLINE
17607 zend_free_op free_op1, free_op2;
17608 zval **container;
17609
17610 SAVE_OPLINE();
17611 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17612
17613 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17614 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17615 }
17616 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
17617 zval_dtor(free_op2.var);
17618 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17619 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17620 }
17621 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17622 CHECK_EXCEPTION();
17623 ZEND_VM_NEXT_OPCODE();
17624 }
17625
ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17626 static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17627 {
17628 USE_OPLINE
17629 zend_free_op free_op1, free_op2;
17630 zval *container;
17631
17632 SAVE_OPLINE();
17633 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17634 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC);
17635 zval_dtor(free_op2.var);
17636 zval_ptr_dtor_nogc(&free_op1.var);
17637 CHECK_EXCEPTION();
17638 ZEND_VM_NEXT_OPCODE();
17639 }
17640
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17641 static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17642 {
17643 USE_OPLINE
17644 zend_free_op free_op1, free_op2;
17645
17646 SAVE_OPLINE();
17647
17648 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
17649 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17650 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17651 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17652 }
17653 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
17654 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17655 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17656 }
17657 zval_dtor(free_op2.var);
17658 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17659 } else {
17660 zval *container;
17661
17662 if (IS_TMP_VAR == IS_UNUSED) {
17663 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
17664 }
17665 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17666 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
17667 zval_dtor(free_op2.var);
17668 zval_ptr_dtor_nogc(&free_op1.var);
17669 }
17670 CHECK_EXCEPTION();
17671 ZEND_VM_NEXT_OPCODE();
17672 }
17673
ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17674 static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17675 {
17676 USE_OPLINE
17677 zend_free_op free_op1, free_op2;
17678 zval **container;
17679
17680 SAVE_OPLINE();
17681 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17682
17683 if (IS_VAR == IS_CV) {
17684 if (container != &EG(uninitialized_zval_ptr)) {
17685 SEPARATE_ZVAL_IF_NOT_REF(container);
17686 }
17687 }
17688 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17689 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17690 }
17691 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_UNSET TSRMLS_CC);
17692 zval_dtor(free_op2.var);
17693 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17694 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17695 }
17696 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17697 if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
17698 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
17699 ZEND_VM_NEXT_OPCODE();
17700 } else {
17701 zend_free_op free_res;
17702 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
17703
17704 PZVAL_UNLOCK(*retval_ptr, &free_res);
17705 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
17706 SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
17707 }
17708 PZVAL_LOCK(*retval_ptr);
17709 FREE_OP_VAR_PTR(free_res);
17710 CHECK_EXCEPTION();
17711 ZEND_VM_NEXT_OPCODE();
17712 }
17713 }
17714
zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS)17715 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS)
17716 {
17717 USE_OPLINE
17718 zend_free_op free_op1;
17719 zval *container;
17720 zend_free_op free_op2;
17721 zval *offset;
17722
17723 SAVE_OPLINE();
17724 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17725 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17726
17727 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
17728 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
17729 zend_error(E_NOTICE, "Trying to get property of non-object");
17730 PZVAL_LOCK(&EG(uninitialized_zval));
17731 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17732 zval_dtor(free_op2.var);
17733 } else {
17734 zval *retval;
17735
17736 if (1) {
17737 MAKE_REAL_ZVAL_PTR(offset);
17738 }
17739
17740 /* here we are sure we are dealing with an object */
17741 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17742
17743 PZVAL_LOCK(retval);
17744 EX_T(opline->result.var).var.ptr = retval;
17745
17746 if (1) {
17747 zval_ptr_dtor(&offset);
17748 } else {
17749 zval_dtor(free_op2.var);
17750 }
17751 }
17752
17753 zval_ptr_dtor_nogc(&free_op1.var);
17754 CHECK_EXCEPTION();
17755 ZEND_VM_NEXT_OPCODE();
17756 }
17757
ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17758 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17759 {
17760 return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17761 }
17762
ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17763 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17764 {
17765 USE_OPLINE
17766 zend_free_op free_op1, free_op2;
17767 zval *property;
17768 zval **container;
17769
17770 SAVE_OPLINE();
17771 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17772
17773 if (1) {
17774 MAKE_REAL_ZVAL_PTR(property);
17775 }
17776 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17777 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17778 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17779 }
17780
17781 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
17782 if (1) {
17783 zval_ptr_dtor(&property);
17784 } else {
17785 zval_dtor(free_op2.var);
17786 }
17787 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17788 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17789 }
17790 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17791
17792 /* We are going to assign the result by reference */
17793 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
17794 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
17795
17796 Z_DELREF_PP(retval_ptr);
17797 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
17798 Z_ADDREF_PP(retval_ptr);
17799 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
17800 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
17801 }
17802
17803 CHECK_EXCEPTION();
17804 ZEND_VM_NEXT_OPCODE();
17805 }
17806
ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17807 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17808 {
17809 USE_OPLINE
17810 zend_free_op free_op1, free_op2;
17811 zval *property;
17812 zval **container;
17813
17814 SAVE_OPLINE();
17815 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17816 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17817
17818 if (1) {
17819 MAKE_REAL_ZVAL_PTR(property);
17820 }
17821 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17822 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17823 }
17824 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
17825 if (1) {
17826 zval_ptr_dtor(&property);
17827 } else {
17828 zval_dtor(free_op2.var);
17829 }
17830 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17831 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17832 }
17833 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17834 CHECK_EXCEPTION();
17835 ZEND_VM_NEXT_OPCODE();
17836 }
17837
ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17838 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17839 {
17840 USE_OPLINE
17841 zend_free_op free_op1;
17842 zval *container;
17843 zend_free_op free_op2;
17844 zval *offset;
17845
17846 SAVE_OPLINE();
17847 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17848 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17849
17850 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
17851 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
17852 PZVAL_LOCK(&EG(uninitialized_zval));
17853 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17854 zval_dtor(free_op2.var);
17855 } else {
17856 zval *retval;
17857
17858 if (1) {
17859 MAKE_REAL_ZVAL_PTR(offset);
17860 }
17861
17862 /* here we are sure we are dealing with an object */
17863 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17864
17865 PZVAL_LOCK(retval);
17866 EX_T(opline->result.var).var.ptr = retval;
17867
17868 if (1) {
17869 zval_ptr_dtor(&offset);
17870 } else {
17871 zval_dtor(free_op2.var);
17872 }
17873 }
17874
17875 zval_ptr_dtor_nogc(&free_op1.var);
17876 CHECK_EXCEPTION();
17877 ZEND_VM_NEXT_OPCODE();
17878 }
17879
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17880 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17881 {
17882 USE_OPLINE
17883
17884 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
17885 /* Behave like FETCH_OBJ_W */
17886 zend_free_op free_op1, free_op2;
17887 zval *property;
17888 zval **container;
17889
17890 SAVE_OPLINE();
17891 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17892 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17893
17894 if (1) {
17895 MAKE_REAL_ZVAL_PTR(property);
17896 }
17897 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17898 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17899 }
17900 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
17901 if (1) {
17902 zval_ptr_dtor(&property);
17903 } else {
17904 zval_dtor(free_op2.var);
17905 }
17906 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17907 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17908 }
17909 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17910 CHECK_EXCEPTION();
17911 ZEND_VM_NEXT_OPCODE();
17912 } else {
17913 return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17914 }
17915 }
17916
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17917 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17918 {
17919 USE_OPLINE
17920 zend_free_op free_op1, free_op2, free_res;
17921 zval **container;
17922 zval *property;
17923
17924 SAVE_OPLINE();
17925 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17926 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17927
17928 if (IS_VAR == IS_CV) {
17929 if (container != &EG(uninitialized_zval_ptr)) {
17930 SEPARATE_ZVAL_IF_NOT_REF(container);
17931 }
17932 }
17933 if (1) {
17934 MAKE_REAL_ZVAL_PTR(property);
17935 }
17936 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17937 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17938 }
17939 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
17940 if (1) {
17941 zval_ptr_dtor(&property);
17942 } else {
17943 zval_dtor(free_op2.var);
17944 }
17945 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17946 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17947 }
17948 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17949
17950 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
17951 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
17952 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
17953 }
17954 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
17955 FREE_OP_VAR_PTR(free_res);
17956 CHECK_EXCEPTION();
17957 ZEND_VM_NEXT_OPCODE();
17958 }
17959
ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17960 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17961 {
17962 USE_OPLINE
17963 zend_free_op free_op1, free_op2;
17964 zval **object_ptr;
17965 zval *property_name;
17966
17967 SAVE_OPLINE();
17968 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17969 property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17970
17971 if (1) {
17972 MAKE_REAL_ZVAL_PTR(property_name);
17973 }
17974 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
17975 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17976 }
17977 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17978 if (1) {
17979 zval_ptr_dtor(&property_name);
17980 } else {
17981 zval_dtor(free_op2.var);
17982 }
17983 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17984 /* assign_obj has two opcodes! */
17985 CHECK_EXCEPTION();
17986 ZEND_VM_INC_OPCODE();
17987 ZEND_VM_NEXT_OPCODE();
17988 }
17989
ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17990 static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17991 {
17992 USE_OPLINE
17993 zend_free_op free_op1;
17994 zval **object_ptr;
17995
17996 SAVE_OPLINE();
17997 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17998
17999 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
18000 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
18001 }
18002 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
18003 zend_free_op free_op2;
18004 zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18005
18006 if (1) {
18007 MAKE_REAL_ZVAL_PTR(property_name);
18008 }
18009 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
18010 if (1) {
18011 zval_ptr_dtor(&property_name);
18012 } else {
18013 zval_dtor(free_op2.var);
18014 }
18015 } else {
18016 zend_free_op free_op2, free_op_data1, free_op_data2;
18017 zval *value;
18018 zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18019 zval **variable_ptr_ptr;
18020
18021 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
18022 zval_dtor(free_op2.var);
18023
18024 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
18025 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
18026 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
18027 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
18028 if (RETURN_VALUE_USED(opline)) {
18029 zval *retval;
18030
18031 ALLOC_ZVAL(retval);
18032 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
18033 INIT_PZVAL(retval);
18034 EX_T(opline->result.var).var.ptr = retval;
18035 }
18036 } else if (RETURN_VALUE_USED(opline)) {
18037 PZVAL_LOCK(&EG(uninitialized_zval));
18038 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
18039 }
18040 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
18041 if (IS_TMP_FREE(free_op_data1)) {
18042 zval_dtor(value);
18043 }
18044 if (RETURN_VALUE_USED(opline)) {
18045 PZVAL_LOCK(&EG(uninitialized_zval));
18046 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
18047 }
18048 } else {
18049 if ((opline+1)->op1_type == IS_TMP_VAR) {
18050 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
18051 } else if ((opline+1)->op1_type == IS_CONST) {
18052 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
18053 } else {
18054 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
18055 }
18056 if (RETURN_VALUE_USED(opline)) {
18057 PZVAL_LOCK(value);
18058 EX_T(opline->result.var).var.ptr = value;
18059 }
18060 }
18061 FREE_OP_VAR_PTR(free_op_data2);
18062 FREE_OP_IF_VAR(free_op_data1);
18063 }
18064 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
18065 /* assign_dim has two opcodes! */
18066 CHECK_EXCEPTION();
18067 ZEND_VM_INC_OPCODE();
18068 ZEND_VM_NEXT_OPCODE();
18069 }
18070
ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18071 static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18072 {
18073 USE_OPLINE
18074 zend_free_op free_op1, free_op2;
18075 zval *value;
18076 zval **variable_ptr_ptr;
18077
18078 SAVE_OPLINE();
18079 value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18080 variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18081
18082 if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
18083 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) {
18084 if (RETURN_VALUE_USED(opline)) {
18085 zval *retval;
18086
18087 ALLOC_ZVAL(retval);
18088 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
18089 INIT_PZVAL(retval);
18090 EX_T(opline->result.var).var.ptr = retval;
18091 }
18092 } else if (RETURN_VALUE_USED(opline)) {
18093 PZVAL_LOCK(&EG(uninitialized_zval));
18094 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
18095 }
18096 } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
18097 if (1) {
18098 zval_dtor(value);
18099 }
18100 if (RETURN_VALUE_USED(opline)) {
18101 PZVAL_LOCK(&EG(uninitialized_zval));
18102 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
18103 }
18104 } else {
18105 if (IS_TMP_VAR == IS_TMP_VAR) {
18106 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
18107 } else if (IS_TMP_VAR == IS_CONST) {
18108 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
18109 } else {
18110 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
18111 }
18112 if (RETURN_VALUE_USED(opline)) {
18113 PZVAL_LOCK(value);
18114 EX_T(opline->result.var).var.ptr = value;
18115 }
18116 }
18117
18118 if (IS_VAR == IS_VAR && (free_op1.var != NULL)) {
18119 zval_ptr_dtor_nogc(&value);
18120 }
18121
18122 /* zend_assign_to_variable() always takes care of op2, never free it! */
18123
18124 CHECK_EXCEPTION();
18125 ZEND_VM_NEXT_OPCODE();
18126 }
18127
ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18128 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18129 {
18130 USE_OPLINE
18131 zval *function_name;
18132 char *function_name_strval;
18133 int function_name_strlen;
18134 zend_free_op free_op1, free_op2;
18135 call_slot *call = EX(call_slots) + opline->result.num;
18136
18137 SAVE_OPLINE();
18138
18139 function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18140
18141 if (IS_TMP_VAR != IS_CONST &&
18142 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
18143 if (UNEXPECTED(EG(exception) != NULL)) {
18144 HANDLE_EXCEPTION();
18145 }
18146 zend_error_noreturn(E_ERROR, "Method name must be a string");
18147 }
18148
18149 function_name_strval = Z_STRVAL_P(function_name);
18150 function_name_strlen = Z_STRLEN_P(function_name);
18151
18152 call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18153
18154 if (EXPECTED(call->object != NULL) &&
18155 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
18156 call->called_scope = Z_OBJCE_P(call->object);
18157
18158 if (IS_TMP_VAR != IS_CONST ||
18159 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
18160 zval *object = call->object;
18161
18162 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
18163 zend_error_noreturn(E_ERROR, "Object does not support method calls");
18164 }
18165
18166 /* First, locate the function. */
18167 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
18168 if (UNEXPECTED(call->fbc == NULL)) {
18169 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
18170 }
18171 if (IS_TMP_VAR == IS_CONST &&
18172 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
18173 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
18174 EXPECTED(call->object == object)) {
18175 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
18176 }
18177 }
18178 } else {
18179 if (UNEXPECTED(EG(exception) != NULL)) {
18180 zval_dtor(free_op2.var);
18181 HANDLE_EXCEPTION();
18182 }
18183 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
18184 }
18185
18186 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
18187 call->object = NULL;
18188 } else {
18189 if (!PZVAL_IS_REF(call->object)) {
18190 Z_ADDREF_P(call->object); /* For $this pointer */
18191 } else {
18192 zval *this_ptr;
18193 ALLOC_ZVAL(this_ptr);
18194 INIT_PZVAL_COPY(this_ptr, call->object);
18195 zval_copy_ctor(this_ptr);
18196 call->object = this_ptr;
18197 }
18198 }
18199
18200 call->num_additional_args = 0;
18201 call->is_ctor_call = 0;
18202 EX(call) = call;
18203
18204 zval_dtor(free_op2.var);
18205 zval_ptr_dtor_nogc(&free_op1.var);
18206
18207 CHECK_EXCEPTION();
18208 ZEND_VM_NEXT_OPCODE();
18209 }
18210
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18211 static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18212 {
18213 USE_OPLINE
18214 zval *function_name;
18215 zend_class_entry *ce;
18216 call_slot *call = EX(call_slots) + opline->result.num;
18217
18218 SAVE_OPLINE();
18219
18220 if (IS_VAR == IS_CONST) {
18221 /* no function found. try a static method in class */
18222 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
18223 ce = CACHED_PTR(opline->op1.literal->cache_slot);
18224 } else {
18225 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
18226 if (UNEXPECTED(EG(exception) != NULL)) {
18227 HANDLE_EXCEPTION();
18228 }
18229 if (UNEXPECTED(ce == NULL)) {
18230 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
18231 }
18232 CACHE_PTR(opline->op1.literal->cache_slot, ce);
18233 }
18234 call->called_scope = ce;
18235 } else {
18236 ce = EX_T(opline->op1.var).class_entry;
18237
18238 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
18239 call->called_scope = EG(called_scope);
18240 } else {
18241 call->called_scope = ce;
18242 }
18243 }
18244
18245 if (IS_VAR == IS_CONST &&
18246 IS_TMP_VAR == IS_CONST &&
18247 CACHED_PTR(opline->op2.literal->cache_slot)) {
18248 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
18249 } else if (IS_VAR != IS_CONST &&
18250 IS_TMP_VAR == IS_CONST &&
18251 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
18252 /* do nothing */
18253 } else if (IS_TMP_VAR != IS_UNUSED) {
18254 char *function_name_strval = NULL;
18255 int function_name_strlen = 0;
18256 zend_free_op free_op2;
18257
18258 if (IS_TMP_VAR == IS_CONST) {
18259 function_name_strval = Z_STRVAL_P(opline->op2.zv);
18260 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
18261 } else {
18262 function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18263
18264 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
18265 if (UNEXPECTED(EG(exception) != NULL)) {
18266 HANDLE_EXCEPTION();
18267 }
18268 zend_error_noreturn(E_ERROR, "Function name must be a string");
18269 } else {
18270 function_name_strval = Z_STRVAL_P(function_name);
18271 function_name_strlen = Z_STRLEN_P(function_name);
18272 }
18273 }
18274
18275 if (function_name_strval) {
18276 if (ce->get_static_method) {
18277 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
18278 } else {
18279 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
18280 }
18281 if (UNEXPECTED(call->fbc == NULL)) {
18282 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
18283 }
18284 if (IS_TMP_VAR == IS_CONST &&
18285 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
18286 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
18287 if (IS_VAR == IS_CONST) {
18288 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
18289 } else {
18290 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
18291 }
18292 }
18293 }
18294 if (IS_TMP_VAR != IS_CONST) {
18295 zval_dtor(free_op2.var);
18296 }
18297 } else {
18298 if (UNEXPECTED(ce->constructor == NULL)) {
18299 zend_error_noreturn(E_ERROR, "Cannot call constructor");
18300 }
18301 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
18302 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
18303 }
18304 call->fbc = ce->constructor;
18305 }
18306
18307 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
18308 call->object = NULL;
18309 } else {
18310 if (EG(This) &&
18311 Z_OBJ_HT_P(EG(This))->get_class_entry &&
18312 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
18313 /* We are calling method of the other (incompatible) class,
18314 but passing $this. This is done for compatibility with php-4. */
18315 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
18316 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
18317 } else {
18318 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
18319 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
18320 }
18321 }
18322 if ((call->object = EG(This))) {
18323 Z_ADDREF_P(call->object);
18324 call->called_scope = Z_OBJCE_P(call->object);
18325 }
18326 }
18327
18328 call->num_additional_args = 0;
18329 call->is_ctor_call = 0;
18330 EX(call) = call;
18331
18332 CHECK_EXCEPTION();
18333 ZEND_VM_NEXT_OPCODE();
18334 }
18335
ZEND_CASE_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18336 static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18337 {
18338 USE_OPLINE
18339 zend_free_op free_op1, free_op2;
18340
18341 SAVE_OPLINE();
18342 is_equal_function(&EX_T(opline->result.var).tmp_var,
18343 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18344 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18345
18346 zval_dtor(free_op2.var);
18347 CHECK_EXCEPTION();
18348 ZEND_VM_NEXT_OPCODE();
18349 }
18350
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18351 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18352 {
18353 USE_OPLINE
18354 zend_free_op free_op1;
18355 zval *expr_ptr;
18356
18357 SAVE_OPLINE();
18358 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
18359 zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18360
18361 if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
18362 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
18363 }
18364 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
18365 expr_ptr = *expr_ptr_ptr;
18366 Z_ADDREF_P(expr_ptr);
18367 } else {
18368 expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18369 if (0) { /* temporary variable */
18370 zval *new_expr;
18371
18372 ALLOC_ZVAL(new_expr);
18373 INIT_PZVAL_COPY(new_expr, expr_ptr);
18374 expr_ptr = new_expr;
18375 } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
18376 zval *new_expr;
18377
18378 ALLOC_ZVAL(new_expr);
18379 INIT_PZVAL_COPY(new_expr, expr_ptr);
18380 expr_ptr = new_expr;
18381 zendi_zval_copy_ctor(*expr_ptr);
18382 zval_ptr_dtor_nogc(&free_op1.var);
18383 } else if (IS_VAR == IS_CV) {
18384 Z_ADDREF_P(expr_ptr);
18385 }
18386 }
18387
18388 if (IS_TMP_VAR != IS_UNUSED) {
18389 zend_free_op free_op2;
18390 zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18391 ulong hval;
18392
18393 switch (Z_TYPE_P(offset)) {
18394 case IS_DOUBLE:
18395 hval = zend_dval_to_lval(Z_DVAL_P(offset));
18396 goto num_index;
18397 case IS_LONG:
18398 case IS_BOOL:
18399 hval = Z_LVAL_P(offset);
18400 num_index:
18401 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
18402 break;
18403 case IS_STRING:
18404 if (IS_TMP_VAR == IS_CONST) {
18405 hval = Z_HASH_P(offset);
18406 } else {
18407 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
18408 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
18409 }
18410 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
18411 break;
18412 case IS_NULL:
18413 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
18414 break;
18415 default:
18416 zend_error(E_WARNING, "Illegal offset type");
18417 zval_ptr_dtor(&expr_ptr);
18418 /* do nothing */
18419 break;
18420 }
18421 zval_dtor(free_op2.var);
18422 } else {
18423 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
18424 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
18425 zval_ptr_dtor(&expr_ptr);
18426 }
18427 }
18428 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
18429 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
18430 }
18431 CHECK_EXCEPTION();
18432 ZEND_VM_NEXT_OPCODE();
18433 }
18434
ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18435 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18436 {
18437 USE_OPLINE
18438
18439 array_init(&EX_T(opline->result.var).tmp_var);
18440 if (IS_VAR == IS_UNUSED) {
18441 ZEND_VM_NEXT_OPCODE();
18442 #if 0 || IS_VAR != IS_UNUSED
18443 } else {
18444 return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18445 #endif
18446 }
18447 }
18448
ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18449 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18450 {
18451 USE_OPLINE
18452 zend_free_op free_op1, free_op2;
18453 zval **container;
18454 zval *offset;
18455 ulong hval;
18456
18457 SAVE_OPLINE();
18458 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18459 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
18460 SEPARATE_ZVAL_IF_NOT_REF(container);
18461 }
18462 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18463
18464 if (IS_VAR != IS_VAR || container) {
18465 switch (Z_TYPE_PP(container)) {
18466 case IS_ARRAY: {
18467 HashTable *ht = Z_ARRVAL_PP(container);
18468
18469 switch (Z_TYPE_P(offset)) {
18470 case IS_DOUBLE:
18471 hval = zend_dval_to_lval(Z_DVAL_P(offset));
18472 zend_hash_index_del(ht, hval);
18473 break;
18474 case IS_RESOURCE:
18475 case IS_BOOL:
18476 case IS_LONG:
18477 hval = Z_LVAL_P(offset);
18478 zend_hash_index_del(ht, hval);
18479 break;
18480 case IS_STRING:
18481 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
18482 Z_ADDREF_P(offset);
18483 }
18484 if (IS_TMP_VAR == IS_CONST) {
18485 hval = Z_HASH_P(offset);
18486 } else {
18487 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
18488 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
18489 }
18490 if (ht == &EG(symbol_table)) {
18491 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
18492 } else {
18493 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
18494 }
18495 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
18496 zval_ptr_dtor(&offset);
18497 }
18498 break;
18499 num_index_dim:
18500 zend_hash_index_del(ht, hval);
18501 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
18502 zval_ptr_dtor(&offset);
18503 }
18504 break;
18505 case IS_NULL:
18506 zend_hash_del(ht, "", sizeof(""));
18507 break;
18508 default:
18509 zend_error(E_WARNING, "Illegal offset type in unset");
18510 break;
18511 }
18512 zval_dtor(free_op2.var);
18513 break;
18514 }
18515 case IS_OBJECT:
18516 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
18517 zend_error_noreturn(E_ERROR, "Cannot use object as array");
18518 }
18519 if (1) {
18520 MAKE_REAL_ZVAL_PTR(offset);
18521 }
18522 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
18523 if (1) {
18524 zval_ptr_dtor(&offset);
18525 } else {
18526 zval_dtor(free_op2.var);
18527 }
18528 break;
18529 case IS_STRING:
18530 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
18531 ZEND_VM_CONTINUE(); /* bailed out before */
18532 default:
18533 zval_dtor(free_op2.var);
18534 break;
18535 }
18536 } else {
18537 zval_dtor(free_op2.var);
18538 }
18539 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
18540
18541 CHECK_EXCEPTION();
18542 ZEND_VM_NEXT_OPCODE();
18543 }
18544
ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18545 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18546 {
18547 USE_OPLINE
18548 zend_free_op free_op1, free_op2;
18549 zval **container;
18550 zval *offset;
18551
18552 SAVE_OPLINE();
18553 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18554 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18555
18556 if (IS_VAR != IS_VAR || container) {
18557 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
18558 SEPARATE_ZVAL_IF_NOT_REF(container);
18559 }
18560 if (Z_TYPE_PP(container) == IS_OBJECT) {
18561 if (1) {
18562 MAKE_REAL_ZVAL_PTR(offset);
18563 }
18564 if (Z_OBJ_HT_P(*container)->unset_property) {
18565 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
18566 } else {
18567 zend_error(E_NOTICE, "Trying to unset property of non-object");
18568 }
18569 if (1) {
18570 zval_ptr_dtor(&offset);
18571 } else {
18572 zval_dtor(free_op2.var);
18573 }
18574 } else {
18575 zval_dtor(free_op2.var);
18576 }
18577 } else {
18578 zval_dtor(free_op2.var);
18579 }
18580 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
18581
18582 CHECK_EXCEPTION();
18583 ZEND_VM_NEXT_OPCODE();
18584 }
18585
zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)18586 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
18587 {
18588 USE_OPLINE
18589 zend_free_op free_op1, free_op2;
18590 zval *container;
18591 zval **value = NULL;
18592 int result = 0;
18593 ulong hval;
18594 zval *offset;
18595
18596 SAVE_OPLINE();
18597 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18598 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18599
18600 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
18601 HashTable *ht;
18602 int isset = 0;
18603
18604 ht = Z_ARRVAL_P(container);
18605
18606 switch (Z_TYPE_P(offset)) {
18607 case IS_DOUBLE:
18608 hval = zend_dval_to_lval(Z_DVAL_P(offset));
18609 goto num_index_prop;
18610 case IS_RESOURCE:
18611 case IS_BOOL:
18612 case IS_LONG:
18613 hval = Z_LVAL_P(offset);
18614 num_index_prop:
18615 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
18616 isset = 1;
18617 }
18618 break;
18619 case IS_STRING:
18620 if (IS_TMP_VAR == IS_CONST) {
18621 hval = Z_HASH_P(offset);
18622 } else {
18623 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
18624 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
18625 }
18626 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
18627 isset = 1;
18628 }
18629 break;
18630 case IS_NULL:
18631 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
18632 isset = 1;
18633 }
18634 break;
18635 default:
18636 zend_error(E_WARNING, "Illegal offset type in isset or empty");
18637 break;
18638 }
18639
18640 if (opline->extended_value & ZEND_ISSET) {
18641 if (isset && Z_TYPE_PP(value) == IS_NULL) {
18642 result = 0;
18643 } else {
18644 result = isset;
18645 }
18646 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
18647 if (!isset || !i_zend_is_true(*value)) {
18648 result = 0;
18649 } else {
18650 result = 1;
18651 }
18652 }
18653 zval_dtor(free_op2.var);
18654 } else if (Z_TYPE_P(container) == IS_OBJECT) {
18655 if (1) {
18656 MAKE_REAL_ZVAL_PTR(offset);
18657 }
18658 if (prop_dim) {
18659 if (Z_OBJ_HT_P(container)->has_property) {
18660 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
18661 } else {
18662 zend_error(E_NOTICE, "Trying to check property of non-object");
18663 result = 0;
18664 }
18665 } else {
18666 if (Z_OBJ_HT_P(container)->has_dimension) {
18667 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
18668 } else {
18669 zend_error(E_NOTICE, "Trying to check element of non-array");
18670 result = 0;
18671 }
18672 }
18673 if (1) {
18674 zval_ptr_dtor(&offset);
18675 } else {
18676 zval_dtor(free_op2.var);
18677 }
18678 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
18679 zval tmp;
18680
18681 if (Z_TYPE_P(offset) != IS_LONG) {
18682 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
18683 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
18684 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
18685 ZVAL_COPY_VALUE(&tmp, offset);
18686 zval_copy_ctor(&tmp);
18687 convert_to_long(&tmp);
18688 offset = &tmp;
18689 } else {
18690 /* can not be converted to proper offset, return "not set" */
18691 result = 0;
18692 }
18693 }
18694 if (Z_TYPE_P(offset) == IS_LONG) {
18695 if (opline->extended_value & ZEND_ISSET) {
18696 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
18697 result = 1;
18698 }
18699 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
18700 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
18701 result = 1;
18702 }
18703 }
18704 }
18705 zval_dtor(free_op2.var);
18706 } else {
18707 zval_dtor(free_op2.var);
18708 }
18709
18710 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
18711 if (opline->extended_value & ZEND_ISSET) {
18712 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
18713 } else {
18714 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
18715 }
18716
18717 zval_ptr_dtor_nogc(&free_op1.var);
18718
18719 CHECK_EXCEPTION();
18720 ZEND_VM_NEXT_OPCODE();
18721 }
18722
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18723 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18724 {
18725 return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18726 }
18727
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18728 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18729 {
18730 return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18731 }
18732
ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18733 static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18734 {
18735 USE_OPLINE
18736
18737 /* The generator object is stored in return_value_ptr_ptr */
18738 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
18739
18740 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
18741 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
18742 }
18743
18744 /* Destroy the previously yielded value */
18745 if (generator->value) {
18746 zval_ptr_dtor(&generator->value);
18747 }
18748
18749 /* Destroy the previously yielded key */
18750 if (generator->key) {
18751 zval_ptr_dtor(&generator->key);
18752 }
18753
18754 /* Set the new yielded value */
18755 if (IS_VAR != IS_UNUSED) {
18756 zend_free_op free_op1;
18757
18758 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
18759 /* Constants and temporary variables aren't yieldable by reference,
18760 * but we still allow them with a notice. */
18761 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
18762 zval *value, *copy;
18763
18764 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
18765
18766 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18767 ALLOC_ZVAL(copy);
18768 INIT_PZVAL_COPY(copy, value);
18769
18770 /* Temporary variables don't need ctor copying */
18771 if (!0) {
18772 zval_copy_ctor(copy);
18773 }
18774
18775 generator->value = copy;
18776 } else {
18777 zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18778
18779 if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
18780 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
18781 }
18782
18783 /* If a function call result is yielded and the function did
18784 * not return by reference we throw a notice. */
18785 if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
18786 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
18787 && EX_T(opline->op1.var).var.fcall_returned_reference)
18788 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
18789 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
18790
18791 Z_ADDREF_PP(value_ptr);
18792 generator->value = *value_ptr;
18793 } else {
18794 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
18795 Z_ADDREF_PP(value_ptr);
18796 generator->value = *value_ptr;
18797 }
18798
18799 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
18800 }
18801 } else {
18802 zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18803
18804 /* Consts, temporary variables and references need copying */
18805 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
18806 || PZVAL_IS_REF(value)
18807 ) {
18808 zval *copy;
18809
18810 ALLOC_ZVAL(copy);
18811 INIT_PZVAL_COPY(copy, value);
18812
18813 /* Temporary variables don't need ctor copying */
18814 if (!0) {
18815 zval_copy_ctor(copy);
18816 }
18817
18818 generator->value = copy;
18819 zval_ptr_dtor_nogc(&free_op1.var);
18820 } else {
18821 if (IS_VAR == IS_CV) {
18822 Z_ADDREF_P(value);
18823 }
18824 generator->value = value;
18825 }
18826 }
18827 } else {
18828 /* If no value was specified yield null */
18829 Z_ADDREF(EG(uninitialized_zval));
18830 generator->value = &EG(uninitialized_zval);
18831 }
18832
18833 /* Set the new yielded key */
18834 if (IS_TMP_VAR != IS_UNUSED) {
18835 zend_free_op free_op2;
18836 zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18837
18838 /* Consts, temporary variables and references need copying */
18839 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
18840 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
18841 ) {
18842 zval *copy;
18843
18844 ALLOC_ZVAL(copy);
18845 INIT_PZVAL_COPY(copy, key);
18846
18847 /* Temporary variables don't need ctor copying */
18848 if (!1) {
18849 zval_copy_ctor(copy);
18850 }
18851
18852 generator->key = copy;
18853 } else {
18854 Z_ADDREF_P(key);
18855 generator->key = key;
18856 }
18857
18858 if (Z_TYPE_P(generator->key) == IS_LONG
18859 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
18860 ) {
18861 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
18862 }
18863
18864 } else {
18865 /* If no key was specified we use auto-increment keys */
18866 generator->largest_used_integer_key++;
18867
18868 ALLOC_INIT_ZVAL(generator->key);
18869 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
18870 }
18871
18872 if (RETURN_VALUE_USED(opline)) {
18873 /* If the return value of yield is used set the send
18874 * target and initialize it to NULL */
18875 generator->send_target = &EX_T(opline->result.var).var.ptr;
18876 Z_ADDREF(EG(uninitialized_zval));
18877 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
18878 } else {
18879 generator->send_target = NULL;
18880 }
18881
18882 /* We increment to the next op, so we are at the correct position when the
18883 * generator is resumed. */
18884 ZEND_VM_INC_OPCODE();
18885
18886 /* The GOTO VM uses a local opline variable. We need to set the opline
18887 * variable in execute_data so we don't resume at an old position. */
18888 SAVE_OPLINE();
18889
18890 ZEND_VM_RETURN();
18891 }
18892
ZEND_POW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18893 static int ZEND_FASTCALL ZEND_POW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18894 {
18895 USE_OPLINE
18896 zend_free_op free_op1, free_op2;
18897
18898 SAVE_OPLINE();
18899 pow_function(&EX_T(opline->result.var).tmp_var,
18900 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18901 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18902 zval_ptr_dtor_nogc(&free_op1.var);
18903 zval_dtor(free_op2.var);
18904 CHECK_EXCEPTION();
18905 ZEND_VM_NEXT_OPCODE();
18906 }
18907
ZEND_ASSIGN_POW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18908 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18909 {
18910 return zend_binary_assign_op_helper_SPEC_VAR_TMP(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18911 }
18912
ZEND_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18913 static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18914 {
18915 USE_OPLINE
18916 zend_free_op free_op1, free_op2;
18917
18918 SAVE_OPLINE();
18919 fast_add_function(&EX_T(opline->result.var).tmp_var,
18920 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18921 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18922 zval_ptr_dtor_nogc(&free_op1.var);
18923 zval_ptr_dtor_nogc(&free_op2.var);
18924 CHECK_EXCEPTION();
18925 ZEND_VM_NEXT_OPCODE();
18926 }
18927
ZEND_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18928 static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18929 {
18930 USE_OPLINE
18931 zend_free_op free_op1, free_op2;
18932
18933 SAVE_OPLINE();
18934 fast_sub_function(&EX_T(opline->result.var).tmp_var,
18935 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18936 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18937 zval_ptr_dtor_nogc(&free_op1.var);
18938 zval_ptr_dtor_nogc(&free_op2.var);
18939 CHECK_EXCEPTION();
18940 ZEND_VM_NEXT_OPCODE();
18941 }
18942
ZEND_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18943 static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18944 {
18945 USE_OPLINE
18946 zend_free_op free_op1, free_op2;
18947
18948 SAVE_OPLINE();
18949 fast_mul_function(&EX_T(opline->result.var).tmp_var,
18950 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18951 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18952 zval_ptr_dtor_nogc(&free_op1.var);
18953 zval_ptr_dtor_nogc(&free_op2.var);
18954 CHECK_EXCEPTION();
18955 ZEND_VM_NEXT_OPCODE();
18956 }
18957
ZEND_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18958 static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18959 {
18960 USE_OPLINE
18961 zend_free_op free_op1, free_op2;
18962
18963 SAVE_OPLINE();
18964 fast_div_function(&EX_T(opline->result.var).tmp_var,
18965 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18966 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18967 zval_ptr_dtor_nogc(&free_op1.var);
18968 zval_ptr_dtor_nogc(&free_op2.var);
18969 CHECK_EXCEPTION();
18970 ZEND_VM_NEXT_OPCODE();
18971 }
18972
ZEND_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18973 static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18974 {
18975 USE_OPLINE
18976 zend_free_op free_op1, free_op2;
18977
18978 SAVE_OPLINE();
18979 fast_mod_function(&EX_T(opline->result.var).tmp_var,
18980 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18981 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18982 zval_ptr_dtor_nogc(&free_op1.var);
18983 zval_ptr_dtor_nogc(&free_op2.var);
18984 CHECK_EXCEPTION();
18985 ZEND_VM_NEXT_OPCODE();
18986 }
18987
ZEND_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18988 static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18989 {
18990 USE_OPLINE
18991 zend_free_op free_op1, free_op2;
18992
18993 SAVE_OPLINE();
18994 shift_left_function(&EX_T(opline->result.var).tmp_var,
18995 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18996 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18997 zval_ptr_dtor_nogc(&free_op1.var);
18998 zval_ptr_dtor_nogc(&free_op2.var);
18999 CHECK_EXCEPTION();
19000 ZEND_VM_NEXT_OPCODE();
19001 }
19002
ZEND_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19003 static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19004 {
19005 USE_OPLINE
19006 zend_free_op free_op1, free_op2;
19007
19008 SAVE_OPLINE();
19009 shift_right_function(&EX_T(opline->result.var).tmp_var,
19010 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19011 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19012 zval_ptr_dtor_nogc(&free_op1.var);
19013 zval_ptr_dtor_nogc(&free_op2.var);
19014 CHECK_EXCEPTION();
19015 ZEND_VM_NEXT_OPCODE();
19016 }
19017
ZEND_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19018 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19019 {
19020 USE_OPLINE
19021 zend_free_op free_op1, free_op2;
19022
19023 SAVE_OPLINE();
19024 concat_function(&EX_T(opline->result.var).tmp_var,
19025 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19026 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19027 zval_ptr_dtor_nogc(&free_op1.var);
19028 zval_ptr_dtor_nogc(&free_op2.var);
19029 CHECK_EXCEPTION();
19030 ZEND_VM_NEXT_OPCODE();
19031 }
19032
ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19033 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19034 {
19035 USE_OPLINE
19036 zend_free_op free_op1, free_op2;
19037
19038 SAVE_OPLINE();
19039 is_identical_function(&EX_T(opline->result.var).tmp_var,
19040 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19041 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19042 zval_ptr_dtor_nogc(&free_op1.var);
19043 zval_ptr_dtor_nogc(&free_op2.var);
19044 CHECK_EXCEPTION();
19045 ZEND_VM_NEXT_OPCODE();
19046 }
19047
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19048 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19049 {
19050 USE_OPLINE
19051 zend_free_op free_op1, free_op2;
19052 zval *result = &EX_T(opline->result.var).tmp_var;
19053
19054 SAVE_OPLINE();
19055 is_identical_function(result,
19056 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19057 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19058 Z_LVAL_P(result) = !Z_LVAL_P(result);
19059 zval_ptr_dtor_nogc(&free_op1.var);
19060 zval_ptr_dtor_nogc(&free_op2.var);
19061 CHECK_EXCEPTION();
19062 ZEND_VM_NEXT_OPCODE();
19063 }
19064
ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19065 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19066 {
19067 USE_OPLINE
19068 zend_free_op free_op1, free_op2;
19069 zval *result = &EX_T(opline->result.var).tmp_var;
19070
19071 SAVE_OPLINE();
19072 ZVAL_BOOL(result, fast_equal_function(result,
19073 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19074 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
19075 zval_ptr_dtor_nogc(&free_op1.var);
19076 zval_ptr_dtor_nogc(&free_op2.var);
19077 CHECK_EXCEPTION();
19078 ZEND_VM_NEXT_OPCODE();
19079 }
19080
ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19081 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19082 {
19083 USE_OPLINE
19084 zend_free_op free_op1, free_op2;
19085 zval *result = &EX_T(opline->result.var).tmp_var;
19086
19087 SAVE_OPLINE();
19088 ZVAL_BOOL(result, fast_not_equal_function(result,
19089 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19090 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
19091 zval_ptr_dtor_nogc(&free_op1.var);
19092 zval_ptr_dtor_nogc(&free_op2.var);
19093 CHECK_EXCEPTION();
19094 ZEND_VM_NEXT_OPCODE();
19095 }
19096
ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19097 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19098 {
19099 USE_OPLINE
19100 zend_free_op free_op1, free_op2;
19101 zval *result = &EX_T(opline->result.var).tmp_var;
19102
19103 SAVE_OPLINE();
19104 ZVAL_BOOL(result, fast_is_smaller_function(result,
19105 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19106 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
19107 zval_ptr_dtor_nogc(&free_op1.var);
19108 zval_ptr_dtor_nogc(&free_op2.var);
19109 CHECK_EXCEPTION();
19110 ZEND_VM_NEXT_OPCODE();
19111 }
19112
ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19113 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19114 {
19115 USE_OPLINE
19116 zend_free_op free_op1, free_op2;
19117 zval *result = &EX_T(opline->result.var).tmp_var;
19118
19119 SAVE_OPLINE();
19120 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
19121 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19122 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
19123 zval_ptr_dtor_nogc(&free_op1.var);
19124 zval_ptr_dtor_nogc(&free_op2.var);
19125 CHECK_EXCEPTION();
19126 ZEND_VM_NEXT_OPCODE();
19127 }
19128
ZEND_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19129 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19130 {
19131 USE_OPLINE
19132 zend_free_op free_op1, free_op2;
19133
19134 SAVE_OPLINE();
19135 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
19136 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19137 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19138 zval_ptr_dtor_nogc(&free_op1.var);
19139 zval_ptr_dtor_nogc(&free_op2.var);
19140 CHECK_EXCEPTION();
19141 ZEND_VM_NEXT_OPCODE();
19142 }
19143
ZEND_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19144 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19145 {
19146 USE_OPLINE
19147 zend_free_op free_op1, free_op2;
19148
19149 SAVE_OPLINE();
19150 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
19151 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19152 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19153 zval_ptr_dtor_nogc(&free_op1.var);
19154 zval_ptr_dtor_nogc(&free_op2.var);
19155 CHECK_EXCEPTION();
19156 ZEND_VM_NEXT_OPCODE();
19157 }
19158
ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19159 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19160 {
19161 USE_OPLINE
19162 zend_free_op free_op1, free_op2;
19163
19164 SAVE_OPLINE();
19165 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
19166 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19167 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19168 zval_ptr_dtor_nogc(&free_op1.var);
19169 zval_ptr_dtor_nogc(&free_op2.var);
19170 CHECK_EXCEPTION();
19171 ZEND_VM_NEXT_OPCODE();
19172 }
19173
ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19174 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19175 {
19176 USE_OPLINE
19177 zend_free_op free_op1, free_op2;
19178
19179 SAVE_OPLINE();
19180 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
19181 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19182 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19183 zval_ptr_dtor_nogc(&free_op1.var);
19184 zval_ptr_dtor_nogc(&free_op2.var);
19185 CHECK_EXCEPTION();
19186 ZEND_VM_NEXT_OPCODE();
19187 }
19188
zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)19189 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
19190 {
19191 USE_OPLINE
19192 zend_free_op free_op1, free_op2, free_op_data1;
19193 zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19194 zval *object;
19195 zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19196 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
19197 int have_get_ptr = 0;
19198
19199 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
19200 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
19201 }
19202
19203 make_real_object(object_ptr TSRMLS_CC);
19204 object = *object_ptr;
19205
19206 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
19207 zend_error(E_WARNING, "Attempt to assign property of non-object");
19208 zval_ptr_dtor_nogc(&free_op2.var);
19209 FREE_OP(free_op_data1);
19210
19211 if (RETURN_VALUE_USED(opline)) {
19212 PZVAL_LOCK(&EG(uninitialized_zval));
19213 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
19214 }
19215 } else {
19216 /* here we are sure we are dealing with an object */
19217 if (0) {
19218 MAKE_REAL_ZVAL_PTR(property);
19219 }
19220
19221 /* here property is a string */
19222 if (opline->extended_value == ZEND_ASSIGN_OBJ
19223 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
19224 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19225 if (zptr != NULL) { /* NULL means no success in getting PTR */
19226 have_get_ptr = 1;
19227 if (UNEXPECTED(*zptr == &EG(error_zval))) {
19228 if (RETURN_VALUE_USED(opline)) {
19229 PZVAL_LOCK(&EG(uninitialized_zval));
19230 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
19231 }
19232 } else {
19233 SEPARATE_ZVAL_IF_NOT_REF(zptr);
19234
19235 binary_op(*zptr, *zptr, value TSRMLS_CC);
19236 if (RETURN_VALUE_USED(opline)) {
19237 PZVAL_LOCK(*zptr);
19238 EX_T(opline->result.var).var.ptr = *zptr;
19239 }
19240 }
19241 }
19242 }
19243
19244 if (!have_get_ptr) {
19245 zval *z = NULL;
19246
19247 Z_ADDREF_P(object);
19248 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
19249 if (Z_OBJ_HT_P(object)->read_property) {
19250 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19251 }
19252 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
19253 if (Z_OBJ_HT_P(object)->read_dimension) {
19254 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
19255 }
19256 }
19257 if (z) {
19258 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
19259 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
19260
19261 if (Z_REFCOUNT_P(z) == 0) {
19262 GC_REMOVE_ZVAL_FROM_BUFFER(z);
19263 zval_dtor(z);
19264 FREE_ZVAL(z);
19265 }
19266 z = value;
19267 }
19268 Z_ADDREF_P(z);
19269 SEPARATE_ZVAL_IF_NOT_REF(&z);
19270 binary_op(z, z, value TSRMLS_CC);
19271 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
19272 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19273 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
19274 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
19275 }
19276 if (RETURN_VALUE_USED(opline)) {
19277 PZVAL_LOCK(z);
19278 EX_T(opline->result.var).var.ptr = z;
19279 }
19280 zval_ptr_dtor(&z);
19281 } else {
19282 zend_error(E_WARNING, "Attempt to assign property of non-object");
19283 if (RETURN_VALUE_USED(opline)) {
19284 PZVAL_LOCK(&EG(uninitialized_zval));
19285 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
19286 }
19287 }
19288 zval_ptr_dtor(&object);
19289 }
19290
19291 if (0) {
19292 zval_ptr_dtor(&property);
19293 } else {
19294 zval_ptr_dtor_nogc(&free_op2.var);
19295 }
19296 FREE_OP(free_op_data1);
19297 }
19298
19299 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19300 /* assign_obj has two opcodes! */
19301 CHECK_EXCEPTION();
19302 ZEND_VM_INC_OPCODE();
19303 ZEND_VM_NEXT_OPCODE();
19304 }
19305
zend_binary_assign_op_helper_SPEC_VAR_VAR(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)19306 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
19307 {
19308 USE_OPLINE
19309 zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
19310 zval **var_ptr;
19311 zval *value;
19312
19313 SAVE_OPLINE();
19314 switch (opline->extended_value) {
19315 case ZEND_ASSIGN_OBJ:
19316 return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19317 break;
19318 case ZEND_ASSIGN_DIM: {
19319 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19320
19321 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19322 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19323 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
19324 if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
19325 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
19326 }
19327 return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19328 } else {
19329 zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19330
19331 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC);
19332 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
19333 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
19334 }
19335 }
19336 break;
19337 default:
19338 value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19339 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19340 /* do nothing */
19341 break;
19342 }
19343
19344 if (UNEXPECTED(var_ptr == NULL)) {
19345 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
19346 }
19347
19348 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
19349 if (RETURN_VALUE_USED(opline)) {
19350 PZVAL_LOCK(&EG(uninitialized_zval));
19351 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
19352 }
19353 zval_ptr_dtor_nogc(&free_op2.var);
19354 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19355 CHECK_EXCEPTION();
19356 if (opline->extended_value == ZEND_ASSIGN_DIM) {
19357 ZEND_VM_INC_OPCODE();
19358 }
19359 ZEND_VM_NEXT_OPCODE();
19360 }
19361
19362 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
19363
19364 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
19365 && Z_OBJ_HANDLER_PP(var_ptr, get)
19366 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
19367 /* proxy object */
19368 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
19369 Z_ADDREF_P(objval);
19370 binary_op(objval, objval, value TSRMLS_CC);
19371 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
19372 zval_ptr_dtor(&objval);
19373 } else {
19374 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
19375 }
19376
19377 if (RETURN_VALUE_USED(opline)) {
19378 PZVAL_LOCK(*var_ptr);
19379 EX_T(opline->result.var).var.ptr = *var_ptr;
19380 }
19381 zval_ptr_dtor_nogc(&free_op2.var);
19382
19383 if (opline->extended_value == ZEND_ASSIGN_DIM) {
19384 FREE_OP(free_op_data1);
19385 FREE_OP_VAR_PTR(free_op_data2);
19386 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19387 CHECK_EXCEPTION();
19388 ZEND_VM_INC_OPCODE();
19389 } else {
19390 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19391 CHECK_EXCEPTION();
19392 }
19393 ZEND_VM_NEXT_OPCODE();
19394 }
19395
ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19396 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19397 {
19398 return zend_binary_assign_op_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19399 }
19400
ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19401 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19402 {
19403 return zend_binary_assign_op_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19404 }
19405
ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19406 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19407 {
19408 return zend_binary_assign_op_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19409 }
19410
ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19411 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19412 {
19413 return zend_binary_assign_op_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19414 }
19415
ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19416 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19417 {
19418 return zend_binary_assign_op_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19419 }
19420
ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19421 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19422 {
19423 return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19424 }
19425
ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19426 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19427 {
19428 return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19429 }
19430
ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19431 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19432 {
19433 return zend_binary_assign_op_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19434 }
19435
ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19436 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19437 {
19438 return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19439 }
19440
ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19441 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19442 {
19443 return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19444 }
19445
ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19446 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19447 {
19448 return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19449 }
19450
zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)19451 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
19452 {
19453 USE_OPLINE
19454 zend_free_op free_op1, free_op2;
19455 zval **object_ptr;
19456 zval *object;
19457 zval *property;
19458 zval **retval;
19459 int have_get_ptr = 0;
19460
19461 SAVE_OPLINE();
19462 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19463 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19464 retval = &EX_T(opline->result.var).var.ptr;
19465
19466 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
19467 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
19468 }
19469
19470 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
19471 object = *object_ptr;
19472
19473 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
19474 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19475 zval_ptr_dtor_nogc(&free_op2.var);
19476 if (RETURN_VALUE_USED(opline)) {
19477 PZVAL_LOCK(&EG(uninitialized_zval));
19478 *retval = &EG(uninitialized_zval);
19479 }
19480 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19481 CHECK_EXCEPTION();
19482 ZEND_VM_NEXT_OPCODE();
19483 }
19484
19485 /* here we are sure we are dealing with an object */
19486
19487 if (0) {
19488 MAKE_REAL_ZVAL_PTR(property);
19489 }
19490
19491 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
19492 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19493 if (zptr != NULL) { /* NULL means no success in getting PTR */
19494 have_get_ptr = 1;
19495 if (UNEXPECTED(*zptr == &EG(error_zval))) {
19496 if (RETURN_VALUE_USED(opline)) {
19497 PZVAL_LOCK(&EG(uninitialized_zval));
19498 *retval = &EG(uninitialized_zval);
19499 }
19500 } else {
19501 SEPARATE_ZVAL_IF_NOT_REF(zptr);
19502
19503 incdec_op(*zptr);
19504 if (RETURN_VALUE_USED(opline)) {
19505 *retval = *zptr;
19506 PZVAL_LOCK(*retval);
19507 }
19508 }
19509 }
19510 }
19511
19512 if (!have_get_ptr) {
19513 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
19514 zval *z;
19515
19516 Z_ADDREF_P(object);
19517 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19518
19519 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
19520 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
19521
19522 if (Z_REFCOUNT_P(z) == 0) {
19523 GC_REMOVE_ZVAL_FROM_BUFFER(z);
19524 zval_dtor(z);
19525 FREE_ZVAL(z);
19526 }
19527 z = value;
19528 }
19529 Z_ADDREF_P(z);
19530 SEPARATE_ZVAL_IF_NOT_REF(&z);
19531 incdec_op(z);
19532 *retval = z;
19533 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19534 zval_ptr_dtor(&object);
19535 SELECTIVE_PZVAL_LOCK(*retval, opline);
19536 zval_ptr_dtor(&z);
19537 } else {
19538 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19539 if (RETURN_VALUE_USED(opline)) {
19540 PZVAL_LOCK(&EG(uninitialized_zval));
19541 *retval = &EG(uninitialized_zval);
19542 }
19543 }
19544 }
19545
19546 if (0) {
19547 zval_ptr_dtor(&property);
19548 } else {
19549 zval_ptr_dtor_nogc(&free_op2.var);
19550 }
19551 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19552 CHECK_EXCEPTION();
19553 ZEND_VM_NEXT_OPCODE();
19554 }
19555
ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19556 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19557 {
19558 return zend_pre_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19559 }
19560
ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19561 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19562 {
19563 return zend_pre_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19564 }
19565
zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)19566 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
19567 {
19568 USE_OPLINE
19569 zend_free_op free_op1, free_op2;
19570 zval **object_ptr;
19571 zval *object;
19572 zval *property;
19573 zval *retval;
19574 int have_get_ptr = 0;
19575
19576 SAVE_OPLINE();
19577 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19578 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19579 retval = &EX_T(opline->result.var).tmp_var;
19580
19581 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
19582 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
19583 }
19584
19585 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
19586 object = *object_ptr;
19587
19588 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
19589 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19590 zval_ptr_dtor_nogc(&free_op2.var);
19591 ZVAL_NULL(retval);
19592 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19593 CHECK_EXCEPTION();
19594 ZEND_VM_NEXT_OPCODE();
19595 }
19596
19597 /* here we are sure we are dealing with an object */
19598
19599 if (0) {
19600 MAKE_REAL_ZVAL_PTR(property);
19601 }
19602
19603 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
19604 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19605 if (zptr != NULL) { /* NULL means no success in getting PTR */
19606 have_get_ptr = 1;
19607 if (UNEXPECTED(*zptr == &EG(error_zval))) {
19608 ZVAL_NULL(retval);
19609 } else {
19610 SEPARATE_ZVAL_IF_NOT_REF(zptr);
19611
19612 ZVAL_COPY_VALUE(retval, *zptr);
19613 zendi_zval_copy_ctor(*retval);
19614
19615 incdec_op(*zptr);
19616 }
19617 }
19618 }
19619
19620 if (!have_get_ptr) {
19621 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
19622 zval *z, *z_copy;
19623
19624 Z_ADDREF_P(object);
19625 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19626 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
19627 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
19628
19629 if (Z_REFCOUNT_P(z) == 0) {
19630 GC_REMOVE_ZVAL_FROM_BUFFER(z);
19631 zval_dtor(z);
19632 FREE_ZVAL(z);
19633 }
19634 z = value;
19635 }
19636 ZVAL_COPY_VALUE(retval, z);
19637 zendi_zval_copy_ctor(*retval);
19638 ALLOC_ZVAL(z_copy);
19639 INIT_PZVAL_COPY(z_copy, z);
19640 zendi_zval_copy_ctor(*z_copy);
19641 incdec_op(z_copy);
19642 Z_ADDREF_P(z);
19643 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19644 zval_ptr_dtor(&object);
19645 zval_ptr_dtor(&z_copy);
19646 zval_ptr_dtor(&z);
19647 } else {
19648 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19649 ZVAL_NULL(retval);
19650 }
19651 }
19652
19653 if (0) {
19654 zval_ptr_dtor(&property);
19655 } else {
19656 zval_ptr_dtor_nogc(&free_op2.var);
19657 }
19658 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19659 CHECK_EXCEPTION();
19660 ZEND_VM_NEXT_OPCODE();
19661 }
19662
ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19663 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19664 {
19665 return zend_post_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19666 }
19667
ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19668 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19669 {
19670 return zend_post_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19671 }
19672
zend_fetch_var_address_helper_SPEC_VAR_VAR(int type,ZEND_OPCODE_HANDLER_ARGS)19673 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
19674 {
19675 USE_OPLINE
19676 zend_free_op free_op1;
19677 zval *varname;
19678 zval **retval;
19679 zval tmp_varname;
19680 HashTable *target_symbol_table;
19681 ulong hash_value;
19682
19683 SAVE_OPLINE();
19684 varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19685
19686 if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
19687 ZVAL_COPY_VALUE(&tmp_varname, varname);
19688 zval_copy_ctor(&tmp_varname);
19689 Z_SET_REFCOUNT(tmp_varname, 1);
19690 Z_UNSET_ISREF(tmp_varname);
19691 convert_to_string(&tmp_varname);
19692 varname = &tmp_varname;
19693 }
19694
19695 if (IS_VAR != IS_UNUSED) {
19696 zend_class_entry *ce;
19697
19698 if (IS_VAR == IS_CONST) {
19699 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
19700 ce = CACHED_PTR(opline->op2.literal->cache_slot);
19701 } else {
19702 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
19703 if (UNEXPECTED(ce == NULL)) {
19704 if (IS_VAR != IS_CONST && varname == &tmp_varname) {
19705 zval_dtor(&tmp_varname);
19706 }
19707 zval_ptr_dtor_nogc(&free_op1.var);
19708 CHECK_EXCEPTION();
19709 ZEND_VM_NEXT_OPCODE();
19710 }
19711 CACHE_PTR(opline->op2.literal->cache_slot, ce);
19712 }
19713 } else {
19714 ce = EX_T(opline->op2.var).class_entry;
19715 }
19716 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
19717 zval_ptr_dtor_nogc(&free_op1.var);
19718 } else {
19719 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
19720 /*
19721 if (!target_symbol_table) {
19722 CHECK_EXCEPTION();
19723 ZEND_VM_NEXT_OPCODE();
19724 }
19725 */
19726 if (IS_VAR == IS_CONST) {
19727 hash_value = Z_HASH_P(varname);
19728 } else {
19729 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
19730 }
19731
19732 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
19733 switch (type) {
19734 case BP_VAR_R:
19735 case BP_VAR_UNSET:
19736 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
19737 /* break missing intentionally */
19738 case BP_VAR_IS:
19739 retval = &EG(uninitialized_zval_ptr);
19740 break;
19741 case BP_VAR_RW:
19742 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
19743 /* break missing intentionally */
19744 case BP_VAR_W:
19745 Z_ADDREF_P(&EG(uninitialized_zval));
19746 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
19747 break;
19748 EMPTY_SWITCH_DEFAULT_CASE()
19749 }
19750 }
19751 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
19752 case ZEND_FETCH_GLOBAL:
19753 if (IS_VAR != IS_TMP_VAR) {
19754 zval_ptr_dtor_nogc(&free_op1.var);
19755 }
19756 break;
19757 case ZEND_FETCH_LOCAL:
19758 zval_ptr_dtor_nogc(&free_op1.var);
19759 break;
19760 case ZEND_FETCH_STATIC:
19761 zval_update_constant(retval, 1 TSRMLS_CC);
19762 break;
19763 case ZEND_FETCH_GLOBAL_LOCK:
19764 if (IS_VAR == IS_VAR && !free_op1.var) {
19765 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
19766 }
19767 break;
19768 }
19769 }
19770
19771
19772 if (IS_VAR != IS_CONST && varname == &tmp_varname) {
19773 zval_dtor(&tmp_varname);
19774 }
19775 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
19776 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
19777 }
19778 PZVAL_LOCK(*retval);
19779 switch (type) {
19780 case BP_VAR_R:
19781 case BP_VAR_IS:
19782 EX_T(opline->result.var).var.ptr = *retval;
19783 break;
19784 case BP_VAR_UNSET: {
19785 zend_free_op free_res;
19786
19787 PZVAL_UNLOCK(*retval, &free_res);
19788 if (retval != &EG(uninitialized_zval_ptr)) {
19789 SEPARATE_ZVAL_IF_NOT_REF(retval);
19790 }
19791 PZVAL_LOCK(*retval);
19792 FREE_OP_VAR_PTR(free_res);
19793 }
19794 /* break missing intentionally */
19795 default:
19796 EX_T(opline->result.var).var.ptr_ptr = retval;
19797 break;
19798 }
19799 CHECK_EXCEPTION();
19800 ZEND_VM_NEXT_OPCODE();
19801 }
19802
ZEND_FETCH_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19803 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19804 {
19805 return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19806 }
19807
ZEND_FETCH_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19808 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19809 {
19810 return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19811 }
19812
ZEND_FETCH_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19813 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19814 {
19815 return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19816 }
19817
ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19818 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19819 {
19820 USE_OPLINE
19821
19822 return zend_fetch_var_address_helper_SPEC_VAR_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19823 }
19824
ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19825 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19826 {
19827 return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19828 }
19829
ZEND_FETCH_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19830 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19831 {
19832 return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19833 }
19834
ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19835 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19836 {
19837 USE_OPLINE
19838 zend_free_op free_op1, free_op2;
19839 zval *container;
19840
19841 SAVE_OPLINE();
19842 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19843 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
19844 zval_ptr_dtor_nogc(&free_op2.var);
19845 if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
19846 zval_ptr_dtor_nogc(&free_op1.var);
19847 }
19848 CHECK_EXCEPTION();
19849 ZEND_VM_NEXT_OPCODE();
19850 }
19851
ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19852 static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19853 {
19854 USE_OPLINE
19855 zend_free_op free_op1, free_op2;
19856 zval **container;
19857
19858 SAVE_OPLINE();
19859 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19860
19861 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19862 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19863 }
19864 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
19865 zval_ptr_dtor_nogc(&free_op2.var);
19866 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
19867 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
19868 }
19869 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19870
19871 /* We are going to assign the result by reference */
19872 if (UNEXPECTED(opline->extended_value != 0)) {
19873 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
19874
19875 if (retval_ptr) {
19876 Z_DELREF_PP(retval_ptr);
19877 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
19878 Z_ADDREF_PP(retval_ptr);
19879 }
19880 }
19881
19882 CHECK_EXCEPTION();
19883 ZEND_VM_NEXT_OPCODE();
19884 }
19885
ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19886 static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19887 {
19888 USE_OPLINE
19889 zend_free_op free_op1, free_op2;
19890 zval **container;
19891
19892 SAVE_OPLINE();
19893 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19894
19895 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19896 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19897 }
19898 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC);
19899 zval_ptr_dtor_nogc(&free_op2.var);
19900 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
19901 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
19902 }
19903 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19904 CHECK_EXCEPTION();
19905 ZEND_VM_NEXT_OPCODE();
19906 }
19907
ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19908 static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19909 {
19910 USE_OPLINE
19911 zend_free_op free_op1, free_op2;
19912 zval *container;
19913
19914 SAVE_OPLINE();
19915 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19916 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC);
19917 zval_ptr_dtor_nogc(&free_op2.var);
19918 zval_ptr_dtor_nogc(&free_op1.var);
19919 CHECK_EXCEPTION();
19920 ZEND_VM_NEXT_OPCODE();
19921 }
19922
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19923 static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19924 {
19925 USE_OPLINE
19926 zend_free_op free_op1, free_op2;
19927
19928 SAVE_OPLINE();
19929
19930 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
19931 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19932 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19933 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19934 }
19935 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
19936 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
19937 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
19938 }
19939 zval_ptr_dtor_nogc(&free_op2.var);
19940 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19941 } else {
19942 zval *container;
19943
19944 if (IS_VAR == IS_UNUSED) {
19945 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
19946 }
19947 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19948 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
19949 zval_ptr_dtor_nogc(&free_op2.var);
19950 zval_ptr_dtor_nogc(&free_op1.var);
19951 }
19952 CHECK_EXCEPTION();
19953 ZEND_VM_NEXT_OPCODE();
19954 }
19955
ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19956 static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19957 {
19958 USE_OPLINE
19959 zend_free_op free_op1, free_op2;
19960 zval **container;
19961
19962 SAVE_OPLINE();
19963 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19964
19965 if (IS_VAR == IS_CV) {
19966 if (container != &EG(uninitialized_zval_ptr)) {
19967 SEPARATE_ZVAL_IF_NOT_REF(container);
19968 }
19969 }
19970 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19971 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19972 }
19973 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_UNSET TSRMLS_CC);
19974 zval_ptr_dtor_nogc(&free_op2.var);
19975 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
19976 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
19977 }
19978 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19979 if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
19980 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
19981 ZEND_VM_NEXT_OPCODE();
19982 } else {
19983 zend_free_op free_res;
19984 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
19985
19986 PZVAL_UNLOCK(*retval_ptr, &free_res);
19987 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
19988 SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
19989 }
19990 PZVAL_LOCK(*retval_ptr);
19991 FREE_OP_VAR_PTR(free_res);
19992 CHECK_EXCEPTION();
19993 ZEND_VM_NEXT_OPCODE();
19994 }
19995 }
19996
zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS)19997 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS)
19998 {
19999 USE_OPLINE
20000 zend_free_op free_op1;
20001 zval *container;
20002 zend_free_op free_op2;
20003 zval *offset;
20004
20005 SAVE_OPLINE();
20006 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20007 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20008
20009 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
20010 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
20011 zend_error(E_NOTICE, "Trying to get property of non-object");
20012 PZVAL_LOCK(&EG(uninitialized_zval));
20013 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20014 zval_ptr_dtor_nogc(&free_op2.var);
20015 } else {
20016 zval *retval;
20017
20018 if (0) {
20019 MAKE_REAL_ZVAL_PTR(offset);
20020 }
20021
20022 /* here we are sure we are dealing with an object */
20023 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
20024
20025 PZVAL_LOCK(retval);
20026 EX_T(opline->result.var).var.ptr = retval;
20027
20028 if (0) {
20029 zval_ptr_dtor(&offset);
20030 } else {
20031 zval_ptr_dtor_nogc(&free_op2.var);
20032 }
20033 }
20034
20035 zval_ptr_dtor_nogc(&free_op1.var);
20036 CHECK_EXCEPTION();
20037 ZEND_VM_NEXT_OPCODE();
20038 }
20039
ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20040 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20041 {
20042 return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20043 }
20044
ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20045 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20046 {
20047 USE_OPLINE
20048 zend_free_op free_op1, free_op2;
20049 zval *property;
20050 zval **container;
20051
20052 SAVE_OPLINE();
20053 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20054
20055 if (0) {
20056 MAKE_REAL_ZVAL_PTR(property);
20057 }
20058 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20059 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
20060 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20061 }
20062
20063 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
20064 if (0) {
20065 zval_ptr_dtor(&property);
20066 } else {
20067 zval_ptr_dtor_nogc(&free_op2.var);
20068 }
20069 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
20070 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
20071 }
20072 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20073
20074 /* We are going to assign the result by reference */
20075 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
20076 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
20077
20078 Z_DELREF_PP(retval_ptr);
20079 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
20080 Z_ADDREF_PP(retval_ptr);
20081 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
20082 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
20083 }
20084
20085 CHECK_EXCEPTION();
20086 ZEND_VM_NEXT_OPCODE();
20087 }
20088
ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20089 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20090 {
20091 USE_OPLINE
20092 zend_free_op free_op1, free_op2;
20093 zval *property;
20094 zval **container;
20095
20096 SAVE_OPLINE();
20097 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20098 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20099
20100 if (0) {
20101 MAKE_REAL_ZVAL_PTR(property);
20102 }
20103 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
20104 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20105 }
20106 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
20107 if (0) {
20108 zval_ptr_dtor(&property);
20109 } else {
20110 zval_ptr_dtor_nogc(&free_op2.var);
20111 }
20112 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
20113 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
20114 }
20115 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20116 CHECK_EXCEPTION();
20117 ZEND_VM_NEXT_OPCODE();
20118 }
20119
ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20120 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20121 {
20122 USE_OPLINE
20123 zend_free_op free_op1;
20124 zval *container;
20125 zend_free_op free_op2;
20126 zval *offset;
20127
20128 SAVE_OPLINE();
20129 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20130 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20131
20132 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
20133 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
20134 PZVAL_LOCK(&EG(uninitialized_zval));
20135 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20136 zval_ptr_dtor_nogc(&free_op2.var);
20137 } else {
20138 zval *retval;
20139
20140 if (0) {
20141 MAKE_REAL_ZVAL_PTR(offset);
20142 }
20143
20144 /* here we are sure we are dealing with an object */
20145 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
20146
20147 PZVAL_LOCK(retval);
20148 EX_T(opline->result.var).var.ptr = retval;
20149
20150 if (0) {
20151 zval_ptr_dtor(&offset);
20152 } else {
20153 zval_ptr_dtor_nogc(&free_op2.var);
20154 }
20155 }
20156
20157 zval_ptr_dtor_nogc(&free_op1.var);
20158 CHECK_EXCEPTION();
20159 ZEND_VM_NEXT_OPCODE();
20160 }
20161
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20162 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20163 {
20164 USE_OPLINE
20165
20166 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
20167 /* Behave like FETCH_OBJ_W */
20168 zend_free_op free_op1, free_op2;
20169 zval *property;
20170 zval **container;
20171
20172 SAVE_OPLINE();
20173 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20174 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20175
20176 if (0) {
20177 MAKE_REAL_ZVAL_PTR(property);
20178 }
20179 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
20180 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20181 }
20182 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
20183 if (0) {
20184 zval_ptr_dtor(&property);
20185 } else {
20186 zval_ptr_dtor_nogc(&free_op2.var);
20187 }
20188 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
20189 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
20190 }
20191 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20192 CHECK_EXCEPTION();
20193 ZEND_VM_NEXT_OPCODE();
20194 } else {
20195 return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20196 }
20197 }
20198
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20199 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20200 {
20201 USE_OPLINE
20202 zend_free_op free_op1, free_op2, free_res;
20203 zval **container;
20204 zval *property;
20205
20206 SAVE_OPLINE();
20207 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20208 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20209
20210 if (IS_VAR == IS_CV) {
20211 if (container != &EG(uninitialized_zval_ptr)) {
20212 SEPARATE_ZVAL_IF_NOT_REF(container);
20213 }
20214 }
20215 if (0) {
20216 MAKE_REAL_ZVAL_PTR(property);
20217 }
20218 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
20219 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20220 }
20221 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
20222 if (0) {
20223 zval_ptr_dtor(&property);
20224 } else {
20225 zval_ptr_dtor_nogc(&free_op2.var);
20226 }
20227 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
20228 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
20229 }
20230 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20231
20232 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
20233 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
20234 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
20235 }
20236 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
20237 FREE_OP_VAR_PTR(free_res);
20238 CHECK_EXCEPTION();
20239 ZEND_VM_NEXT_OPCODE();
20240 }
20241
ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20242 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20243 {
20244 USE_OPLINE
20245 zend_free_op free_op1, free_op2;
20246 zval **object_ptr;
20247 zval *property_name;
20248
20249 SAVE_OPLINE();
20250 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20251 property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20252
20253 if (0) {
20254 MAKE_REAL_ZVAL_PTR(property_name);
20255 }
20256 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
20257 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
20258 }
20259 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
20260 if (0) {
20261 zval_ptr_dtor(&property_name);
20262 } else {
20263 zval_ptr_dtor_nogc(&free_op2.var);
20264 }
20265 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20266 /* assign_obj has two opcodes! */
20267 CHECK_EXCEPTION();
20268 ZEND_VM_INC_OPCODE();
20269 ZEND_VM_NEXT_OPCODE();
20270 }
20271
ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20272 static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20273 {
20274 USE_OPLINE
20275 zend_free_op free_op1;
20276 zval **object_ptr;
20277
20278 SAVE_OPLINE();
20279 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20280
20281 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
20282 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
20283 }
20284 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
20285 zend_free_op free_op2;
20286 zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20287
20288 if (0) {
20289 MAKE_REAL_ZVAL_PTR(property_name);
20290 }
20291 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
20292 if (0) {
20293 zval_ptr_dtor(&property_name);
20294 } else {
20295 zval_ptr_dtor_nogc(&free_op2.var);
20296 }
20297 } else {
20298 zend_free_op free_op2, free_op_data1, free_op_data2;
20299 zval *value;
20300 zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20301 zval **variable_ptr_ptr;
20302
20303 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_VAR, BP_VAR_W TSRMLS_CC);
20304 zval_ptr_dtor_nogc(&free_op2.var);
20305
20306 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
20307 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
20308 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
20309 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
20310 if (RETURN_VALUE_USED(opline)) {
20311 zval *retval;
20312
20313 ALLOC_ZVAL(retval);
20314 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
20315 INIT_PZVAL(retval);
20316 EX_T(opline->result.var).var.ptr = retval;
20317 }
20318 } else if (RETURN_VALUE_USED(opline)) {
20319 PZVAL_LOCK(&EG(uninitialized_zval));
20320 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20321 }
20322 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
20323 if (IS_TMP_FREE(free_op_data1)) {
20324 zval_dtor(value);
20325 }
20326 if (RETURN_VALUE_USED(opline)) {
20327 PZVAL_LOCK(&EG(uninitialized_zval));
20328 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20329 }
20330 } else {
20331 if ((opline+1)->op1_type == IS_TMP_VAR) {
20332 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20333 } else if ((opline+1)->op1_type == IS_CONST) {
20334 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20335 } else {
20336 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20337 }
20338 if (RETURN_VALUE_USED(opline)) {
20339 PZVAL_LOCK(value);
20340 EX_T(opline->result.var).var.ptr = value;
20341 }
20342 }
20343 FREE_OP_VAR_PTR(free_op_data2);
20344 FREE_OP_IF_VAR(free_op_data1);
20345 }
20346 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20347 /* assign_dim has two opcodes! */
20348 CHECK_EXCEPTION();
20349 ZEND_VM_INC_OPCODE();
20350 ZEND_VM_NEXT_OPCODE();
20351 }
20352
ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20353 static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20354 {
20355 USE_OPLINE
20356 zend_free_op free_op1, free_op2;
20357 zval *value;
20358 zval **variable_ptr_ptr;
20359
20360 SAVE_OPLINE();
20361 value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20362 variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20363
20364 if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
20365 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_VAR TSRMLS_CC)) {
20366 if (RETURN_VALUE_USED(opline)) {
20367 zval *retval;
20368
20369 ALLOC_ZVAL(retval);
20370 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
20371 INIT_PZVAL(retval);
20372 EX_T(opline->result.var).var.ptr = retval;
20373 }
20374 } else if (RETURN_VALUE_USED(opline)) {
20375 PZVAL_LOCK(&EG(uninitialized_zval));
20376 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20377 }
20378 } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
20379 if (0) {
20380 zval_dtor(value);
20381 }
20382 if (RETURN_VALUE_USED(opline)) {
20383 PZVAL_LOCK(&EG(uninitialized_zval));
20384 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20385 }
20386 } else {
20387 if (IS_VAR == IS_TMP_VAR) {
20388 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20389 } else if (IS_VAR == IS_CONST) {
20390 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20391 } else {
20392 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20393 }
20394 if (RETURN_VALUE_USED(opline)) {
20395 PZVAL_LOCK(value);
20396 EX_T(opline->result.var).var.ptr = value;
20397 }
20398 }
20399
20400 if (IS_VAR == IS_VAR && (free_op1.var != NULL)) {
20401 zval_ptr_dtor_nogc(&value);
20402 }
20403
20404 /* zend_assign_to_variable() always takes care of op2, never free it! */
20405 zval_ptr_dtor_nogc(&free_op2.var);
20406
20407 CHECK_EXCEPTION();
20408 ZEND_VM_NEXT_OPCODE();
20409 }
20410
ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20411 static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20412 {
20413 USE_OPLINE
20414 zend_free_op free_op1, free_op2;
20415 zval **variable_ptr_ptr;
20416 zval **value_ptr_ptr;
20417
20418 SAVE_OPLINE();
20419 value_ptr_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20420
20421 if (IS_VAR == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
20422 zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
20423 }
20424
20425 if (IS_VAR == IS_VAR &&
20426 value_ptr_ptr &&
20427 !Z_ISREF_PP(value_ptr_ptr) &&
20428 opline->extended_value == ZEND_RETURNS_FUNCTION &&
20429 !EX_T(opline->op2.var).var.fcall_returned_reference) {
20430 if (free_op2.var == NULL) {
20431 PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
20432 }
20433 zend_error(E_STRICT, "Only variables should be assigned by reference");
20434 if (UNEXPECTED(EG(exception) != NULL)) {
20435 if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
20436 HANDLE_EXCEPTION();
20437 }
20438 return ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20439 } else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
20440 PZVAL_LOCK(*value_ptr_ptr);
20441 }
20442
20443 variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20444 if ((IS_VAR == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
20445 (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
20446 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
20447 } else if ((IS_VAR == IS_VAR && UNEXPECTED(*value_ptr_ptr == &EG(error_zval))) ||
20448 (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval)))) {
20449 variable_ptr_ptr = &EG(uninitialized_zval_ptr);
20450 } else {
20451 zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
20452 if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
20453 Z_DELREF_PP(variable_ptr_ptr);
20454 }
20455 }
20456
20457 if (RETURN_VALUE_USED(opline)) {
20458 PZVAL_LOCK(*variable_ptr_ptr);
20459 EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
20460 }
20461
20462 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20463 if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
20464
20465 CHECK_EXCEPTION();
20466 ZEND_VM_NEXT_OPCODE();
20467 }
20468
ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20469 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20470 {
20471 USE_OPLINE
20472 zval *function_name;
20473 char *function_name_strval;
20474 int function_name_strlen;
20475 zend_free_op free_op1, free_op2;
20476 call_slot *call = EX(call_slots) + opline->result.num;
20477
20478 SAVE_OPLINE();
20479
20480 function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20481
20482 if (IS_VAR != IS_CONST &&
20483 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
20484 if (UNEXPECTED(EG(exception) != NULL)) {
20485 HANDLE_EXCEPTION();
20486 }
20487 zend_error_noreturn(E_ERROR, "Method name must be a string");
20488 }
20489
20490 function_name_strval = Z_STRVAL_P(function_name);
20491 function_name_strlen = Z_STRLEN_P(function_name);
20492
20493 call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20494
20495 if (EXPECTED(call->object != NULL) &&
20496 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
20497 call->called_scope = Z_OBJCE_P(call->object);
20498
20499 if (IS_VAR != IS_CONST ||
20500 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
20501 zval *object = call->object;
20502
20503 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
20504 zend_error_noreturn(E_ERROR, "Object does not support method calls");
20505 }
20506
20507 /* First, locate the function. */
20508 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
20509 if (UNEXPECTED(call->fbc == NULL)) {
20510 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
20511 }
20512 if (IS_VAR == IS_CONST &&
20513 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
20514 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
20515 EXPECTED(call->object == object)) {
20516 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
20517 }
20518 }
20519 } else {
20520 if (UNEXPECTED(EG(exception) != NULL)) {
20521 zval_ptr_dtor_nogc(&free_op2.var);
20522 HANDLE_EXCEPTION();
20523 }
20524 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
20525 }
20526
20527 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
20528 call->object = NULL;
20529 } else {
20530 if (!PZVAL_IS_REF(call->object)) {
20531 Z_ADDREF_P(call->object); /* For $this pointer */
20532 } else {
20533 zval *this_ptr;
20534 ALLOC_ZVAL(this_ptr);
20535 INIT_PZVAL_COPY(this_ptr, call->object);
20536 zval_copy_ctor(this_ptr);
20537 call->object = this_ptr;
20538 }
20539 }
20540
20541 call->num_additional_args = 0;
20542 call->is_ctor_call = 0;
20543 EX(call) = call;
20544
20545 zval_ptr_dtor_nogc(&free_op2.var);
20546 zval_ptr_dtor_nogc(&free_op1.var);
20547
20548 CHECK_EXCEPTION();
20549 ZEND_VM_NEXT_OPCODE();
20550 }
20551
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20552 static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20553 {
20554 USE_OPLINE
20555 zval *function_name;
20556 zend_class_entry *ce;
20557 call_slot *call = EX(call_slots) + opline->result.num;
20558
20559 SAVE_OPLINE();
20560
20561 if (IS_VAR == IS_CONST) {
20562 /* no function found. try a static method in class */
20563 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
20564 ce = CACHED_PTR(opline->op1.literal->cache_slot);
20565 } else {
20566 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
20567 if (UNEXPECTED(EG(exception) != NULL)) {
20568 HANDLE_EXCEPTION();
20569 }
20570 if (UNEXPECTED(ce == NULL)) {
20571 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
20572 }
20573 CACHE_PTR(opline->op1.literal->cache_slot, ce);
20574 }
20575 call->called_scope = ce;
20576 } else {
20577 ce = EX_T(opline->op1.var).class_entry;
20578
20579 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
20580 call->called_scope = EG(called_scope);
20581 } else {
20582 call->called_scope = ce;
20583 }
20584 }
20585
20586 if (IS_VAR == IS_CONST &&
20587 IS_VAR == IS_CONST &&
20588 CACHED_PTR(opline->op2.literal->cache_slot)) {
20589 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
20590 } else if (IS_VAR != IS_CONST &&
20591 IS_VAR == IS_CONST &&
20592 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
20593 /* do nothing */
20594 } else if (IS_VAR != IS_UNUSED) {
20595 char *function_name_strval = NULL;
20596 int function_name_strlen = 0;
20597 zend_free_op free_op2;
20598
20599 if (IS_VAR == IS_CONST) {
20600 function_name_strval = Z_STRVAL_P(opline->op2.zv);
20601 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
20602 } else {
20603 function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20604
20605 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
20606 if (UNEXPECTED(EG(exception) != NULL)) {
20607 HANDLE_EXCEPTION();
20608 }
20609 zend_error_noreturn(E_ERROR, "Function name must be a string");
20610 } else {
20611 function_name_strval = Z_STRVAL_P(function_name);
20612 function_name_strlen = Z_STRLEN_P(function_name);
20613 }
20614 }
20615
20616 if (function_name_strval) {
20617 if (ce->get_static_method) {
20618 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
20619 } else {
20620 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
20621 }
20622 if (UNEXPECTED(call->fbc == NULL)) {
20623 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
20624 }
20625 if (IS_VAR == IS_CONST &&
20626 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
20627 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
20628 if (IS_VAR == IS_CONST) {
20629 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
20630 } else {
20631 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
20632 }
20633 }
20634 }
20635 if (IS_VAR != IS_CONST) {
20636 zval_ptr_dtor_nogc(&free_op2.var);
20637 }
20638 } else {
20639 if (UNEXPECTED(ce->constructor == NULL)) {
20640 zend_error_noreturn(E_ERROR, "Cannot call constructor");
20641 }
20642 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
20643 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
20644 }
20645 call->fbc = ce->constructor;
20646 }
20647
20648 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
20649 call->object = NULL;
20650 } else {
20651 if (EG(This) &&
20652 Z_OBJ_HT_P(EG(This))->get_class_entry &&
20653 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
20654 /* We are calling method of the other (incompatible) class,
20655 but passing $this. This is done for compatibility with php-4. */
20656 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
20657 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
20658 } else {
20659 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
20660 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
20661 }
20662 }
20663 if ((call->object = EG(This))) {
20664 Z_ADDREF_P(call->object);
20665 call->called_scope = Z_OBJCE_P(call->object);
20666 }
20667 }
20668
20669 call->num_additional_args = 0;
20670 call->is_ctor_call = 0;
20671 EX(call) = call;
20672
20673 CHECK_EXCEPTION();
20674 ZEND_VM_NEXT_OPCODE();
20675 }
20676
ZEND_CASE_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20677 static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20678 {
20679 USE_OPLINE
20680 zend_free_op free_op1, free_op2;
20681
20682 SAVE_OPLINE();
20683 is_equal_function(&EX_T(opline->result.var).tmp_var,
20684 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
20685 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
20686
20687 zval_ptr_dtor_nogc(&free_op2.var);
20688 CHECK_EXCEPTION();
20689 ZEND_VM_NEXT_OPCODE();
20690 }
20691
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20692 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20693 {
20694 USE_OPLINE
20695 zend_free_op free_op1;
20696 zval *expr_ptr;
20697
20698 SAVE_OPLINE();
20699 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
20700 zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20701
20702 if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
20703 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
20704 }
20705 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
20706 expr_ptr = *expr_ptr_ptr;
20707 Z_ADDREF_P(expr_ptr);
20708 } else {
20709 expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20710 if (0) { /* temporary variable */
20711 zval *new_expr;
20712
20713 ALLOC_ZVAL(new_expr);
20714 INIT_PZVAL_COPY(new_expr, expr_ptr);
20715 expr_ptr = new_expr;
20716 } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
20717 zval *new_expr;
20718
20719 ALLOC_ZVAL(new_expr);
20720 INIT_PZVAL_COPY(new_expr, expr_ptr);
20721 expr_ptr = new_expr;
20722 zendi_zval_copy_ctor(*expr_ptr);
20723 zval_ptr_dtor_nogc(&free_op1.var);
20724 } else if (IS_VAR == IS_CV) {
20725 Z_ADDREF_P(expr_ptr);
20726 }
20727 }
20728
20729 if (IS_VAR != IS_UNUSED) {
20730 zend_free_op free_op2;
20731 zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20732 ulong hval;
20733
20734 switch (Z_TYPE_P(offset)) {
20735 case IS_DOUBLE:
20736 hval = zend_dval_to_lval(Z_DVAL_P(offset));
20737 goto num_index;
20738 case IS_LONG:
20739 case IS_BOOL:
20740 hval = Z_LVAL_P(offset);
20741 num_index:
20742 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
20743 break;
20744 case IS_STRING:
20745 if (IS_VAR == IS_CONST) {
20746 hval = Z_HASH_P(offset);
20747 } else {
20748 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
20749 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
20750 }
20751 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
20752 break;
20753 case IS_NULL:
20754 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
20755 break;
20756 default:
20757 zend_error(E_WARNING, "Illegal offset type");
20758 zval_ptr_dtor(&expr_ptr);
20759 /* do nothing */
20760 break;
20761 }
20762 zval_ptr_dtor_nogc(&free_op2.var);
20763 } else {
20764 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
20765 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
20766 zval_ptr_dtor(&expr_ptr);
20767 }
20768 }
20769 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
20770 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20771 }
20772 CHECK_EXCEPTION();
20773 ZEND_VM_NEXT_OPCODE();
20774 }
20775
ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20776 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20777 {
20778 USE_OPLINE
20779
20780 array_init(&EX_T(opline->result.var).tmp_var);
20781 if (IS_VAR == IS_UNUSED) {
20782 ZEND_VM_NEXT_OPCODE();
20783 #if 0 || IS_VAR != IS_UNUSED
20784 } else {
20785 return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20786 #endif
20787 }
20788 }
20789
ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20790 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20791 {
20792 USE_OPLINE
20793 zval tmp, *varname;
20794 HashTable *target_symbol_table;
20795 zend_free_op free_op1;
20796
20797 SAVE_OPLINE();
20798 if (IS_VAR == IS_CV &&
20799 IS_VAR == IS_UNUSED &&
20800 (opline->extended_value & ZEND_QUICK_SET)) {
20801 if (EG(active_symbol_table)) {
20802 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
20803
20804 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
20805 EX_CV(opline->op1.var) = NULL;
20806 } else if (EX_CV(opline->op1.var)) {
20807 zval_ptr_dtor(EX_CV(opline->op1.var));
20808 EX_CV(opline->op1.var) = NULL;
20809 }
20810 CHECK_EXCEPTION();
20811 ZEND_VM_NEXT_OPCODE();
20812 }
20813
20814 varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20815
20816 if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
20817 ZVAL_COPY_VALUE(&tmp, varname);
20818 zval_copy_ctor(&tmp);
20819 convert_to_string(&tmp);
20820 varname = &tmp;
20821 } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
20822 Z_ADDREF_P(varname);
20823 }
20824
20825 if (IS_VAR != IS_UNUSED) {
20826 zend_class_entry *ce;
20827
20828 if (IS_VAR == IS_CONST) {
20829 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
20830 ce = CACHED_PTR(opline->op2.literal->cache_slot);
20831 } else {
20832 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
20833 if (UNEXPECTED(EG(exception) != NULL)) {
20834 if (IS_VAR != IS_CONST && varname == &tmp) {
20835 zval_dtor(&tmp);
20836 } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
20837 zval_ptr_dtor(&varname);
20838 }
20839 zval_ptr_dtor_nogc(&free_op1.var);
20840 HANDLE_EXCEPTION();
20841 }
20842 if (UNEXPECTED(ce == NULL)) {
20843 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
20844 }
20845 CACHE_PTR(opline->op2.literal->cache_slot, ce);
20846 }
20847 } else {
20848 ce = EX_T(opline->op2.var).class_entry;
20849 }
20850 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
20851 } else {
20852 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
20853
20854 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
20855 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
20856 }
20857
20858 if (IS_VAR != IS_CONST && varname == &tmp) {
20859 zval_dtor(&tmp);
20860 } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
20861 zval_ptr_dtor(&varname);
20862 }
20863 zval_ptr_dtor_nogc(&free_op1.var);
20864 CHECK_EXCEPTION();
20865 ZEND_VM_NEXT_OPCODE();
20866 }
20867
ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20868 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20869 {
20870 USE_OPLINE
20871 zend_free_op free_op1, free_op2;
20872 zval **container;
20873 zval *offset;
20874 ulong hval;
20875
20876 SAVE_OPLINE();
20877 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20878 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
20879 SEPARATE_ZVAL_IF_NOT_REF(container);
20880 }
20881 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20882
20883 if (IS_VAR != IS_VAR || container) {
20884 switch (Z_TYPE_PP(container)) {
20885 case IS_ARRAY: {
20886 HashTable *ht = Z_ARRVAL_PP(container);
20887
20888 switch (Z_TYPE_P(offset)) {
20889 case IS_DOUBLE:
20890 hval = zend_dval_to_lval(Z_DVAL_P(offset));
20891 zend_hash_index_del(ht, hval);
20892 break;
20893 case IS_RESOURCE:
20894 case IS_BOOL:
20895 case IS_LONG:
20896 hval = Z_LVAL_P(offset);
20897 zend_hash_index_del(ht, hval);
20898 break;
20899 case IS_STRING:
20900 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
20901 Z_ADDREF_P(offset);
20902 }
20903 if (IS_VAR == IS_CONST) {
20904 hval = Z_HASH_P(offset);
20905 } else {
20906 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
20907 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
20908 }
20909 if (ht == &EG(symbol_table)) {
20910 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
20911 } else {
20912 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
20913 }
20914 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
20915 zval_ptr_dtor(&offset);
20916 }
20917 break;
20918 num_index_dim:
20919 zend_hash_index_del(ht, hval);
20920 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
20921 zval_ptr_dtor(&offset);
20922 }
20923 break;
20924 case IS_NULL:
20925 zend_hash_del(ht, "", sizeof(""));
20926 break;
20927 default:
20928 zend_error(E_WARNING, "Illegal offset type in unset");
20929 break;
20930 }
20931 zval_ptr_dtor_nogc(&free_op2.var);
20932 break;
20933 }
20934 case IS_OBJECT:
20935 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
20936 zend_error_noreturn(E_ERROR, "Cannot use object as array");
20937 }
20938 if (0) {
20939 MAKE_REAL_ZVAL_PTR(offset);
20940 }
20941 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
20942 if (0) {
20943 zval_ptr_dtor(&offset);
20944 } else {
20945 zval_ptr_dtor_nogc(&free_op2.var);
20946 }
20947 break;
20948 case IS_STRING:
20949 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
20950 ZEND_VM_CONTINUE(); /* bailed out before */
20951 default:
20952 zval_ptr_dtor_nogc(&free_op2.var);
20953 break;
20954 }
20955 } else {
20956 zval_ptr_dtor_nogc(&free_op2.var);
20957 }
20958 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20959
20960 CHECK_EXCEPTION();
20961 ZEND_VM_NEXT_OPCODE();
20962 }
20963
ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20964 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20965 {
20966 USE_OPLINE
20967 zend_free_op free_op1, free_op2;
20968 zval **container;
20969 zval *offset;
20970
20971 SAVE_OPLINE();
20972 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20973 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20974
20975 if (IS_VAR != IS_VAR || container) {
20976 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
20977 SEPARATE_ZVAL_IF_NOT_REF(container);
20978 }
20979 if (Z_TYPE_PP(container) == IS_OBJECT) {
20980 if (0) {
20981 MAKE_REAL_ZVAL_PTR(offset);
20982 }
20983 if (Z_OBJ_HT_P(*container)->unset_property) {
20984 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
20985 } else {
20986 zend_error(E_NOTICE, "Trying to unset property of non-object");
20987 }
20988 if (0) {
20989 zval_ptr_dtor(&offset);
20990 } else {
20991 zval_ptr_dtor_nogc(&free_op2.var);
20992 }
20993 } else {
20994 zval_ptr_dtor_nogc(&free_op2.var);
20995 }
20996 } else {
20997 zval_ptr_dtor_nogc(&free_op2.var);
20998 }
20999 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21000
21001 CHECK_EXCEPTION();
21002 ZEND_VM_NEXT_OPCODE();
21003 }
21004
ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21005 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21006 {
21007 USE_OPLINE
21008 zval **value;
21009 zend_bool isset = 1;
21010
21011 SAVE_OPLINE();
21012 if (IS_VAR == IS_CV &&
21013 IS_VAR == IS_UNUSED &&
21014 (opline->extended_value & ZEND_QUICK_SET)) {
21015 if (EX_CV(opline->op1.var)) {
21016 value = EX_CV(opline->op1.var);
21017 } else if (EG(active_symbol_table)) {
21018 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
21019
21020 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
21021 isset = 0;
21022 }
21023 } else {
21024 isset = 0;
21025 }
21026 } else {
21027 HashTable *target_symbol_table;
21028 zend_free_op free_op1;
21029 zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21030
21031 if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
21032 ZVAL_COPY_VALUE(&tmp, varname);
21033 zval_copy_ctor(&tmp);
21034 convert_to_string(&tmp);
21035 varname = &tmp;
21036 }
21037
21038 if (IS_VAR != IS_UNUSED) {
21039 zend_class_entry *ce;
21040
21041 if (IS_VAR == IS_CONST) {
21042 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
21043 ce = CACHED_PTR(opline->op2.literal->cache_slot);
21044 } else {
21045 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
21046 if (UNEXPECTED(ce == NULL)) {
21047 CHECK_EXCEPTION();
21048 ZEND_VM_NEXT_OPCODE();
21049 }
21050 CACHE_PTR(opline->op2.literal->cache_slot, ce);
21051 }
21052 } else {
21053 ce = EX_T(opline->op2.var).class_entry;
21054 }
21055 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
21056 if (!value) {
21057 isset = 0;
21058 }
21059 } else {
21060 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
21061 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
21062 isset = 0;
21063 }
21064 }
21065
21066 if (IS_VAR != IS_CONST && varname == &tmp) {
21067 zval_dtor(&tmp);
21068 }
21069 zval_ptr_dtor_nogc(&free_op1.var);
21070 }
21071
21072 if (opline->extended_value & ZEND_ISSET) {
21073 if (isset && Z_TYPE_PP(value) != IS_NULL) {
21074 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
21075 } else {
21076 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
21077 }
21078 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
21079 if (!isset || !i_zend_is_true(*value)) {
21080 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
21081 } else {
21082 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
21083 }
21084 }
21085
21086 CHECK_EXCEPTION();
21087 ZEND_VM_NEXT_OPCODE();
21088 }
21089
zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)21090 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
21091 {
21092 USE_OPLINE
21093 zend_free_op free_op1, free_op2;
21094 zval *container;
21095 zval **value = NULL;
21096 int result = 0;
21097 ulong hval;
21098 zval *offset;
21099
21100 SAVE_OPLINE();
21101 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21102 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
21103
21104 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
21105 HashTable *ht;
21106 int isset = 0;
21107
21108 ht = Z_ARRVAL_P(container);
21109
21110 switch (Z_TYPE_P(offset)) {
21111 case IS_DOUBLE:
21112 hval = zend_dval_to_lval(Z_DVAL_P(offset));
21113 goto num_index_prop;
21114 case IS_RESOURCE:
21115 case IS_BOOL:
21116 case IS_LONG:
21117 hval = Z_LVAL_P(offset);
21118 num_index_prop:
21119 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
21120 isset = 1;
21121 }
21122 break;
21123 case IS_STRING:
21124 if (IS_VAR == IS_CONST) {
21125 hval = Z_HASH_P(offset);
21126 } else {
21127 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
21128 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
21129 }
21130 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
21131 isset = 1;
21132 }
21133 break;
21134 case IS_NULL:
21135 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
21136 isset = 1;
21137 }
21138 break;
21139 default:
21140 zend_error(E_WARNING, "Illegal offset type in isset or empty");
21141 break;
21142 }
21143
21144 if (opline->extended_value & ZEND_ISSET) {
21145 if (isset && Z_TYPE_PP(value) == IS_NULL) {
21146 result = 0;
21147 } else {
21148 result = isset;
21149 }
21150 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
21151 if (!isset || !i_zend_is_true(*value)) {
21152 result = 0;
21153 } else {
21154 result = 1;
21155 }
21156 }
21157 zval_ptr_dtor_nogc(&free_op2.var);
21158 } else if (Z_TYPE_P(container) == IS_OBJECT) {
21159 if (0) {
21160 MAKE_REAL_ZVAL_PTR(offset);
21161 }
21162 if (prop_dim) {
21163 if (Z_OBJ_HT_P(container)->has_property) {
21164 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
21165 } else {
21166 zend_error(E_NOTICE, "Trying to check property of non-object");
21167 result = 0;
21168 }
21169 } else {
21170 if (Z_OBJ_HT_P(container)->has_dimension) {
21171 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
21172 } else {
21173 zend_error(E_NOTICE, "Trying to check element of non-array");
21174 result = 0;
21175 }
21176 }
21177 if (0) {
21178 zval_ptr_dtor(&offset);
21179 } else {
21180 zval_ptr_dtor_nogc(&free_op2.var);
21181 }
21182 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
21183 zval tmp;
21184
21185 if (Z_TYPE_P(offset) != IS_LONG) {
21186 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
21187 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
21188 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
21189 ZVAL_COPY_VALUE(&tmp, offset);
21190 zval_copy_ctor(&tmp);
21191 convert_to_long(&tmp);
21192 offset = &tmp;
21193 } else {
21194 /* can not be converted to proper offset, return "not set" */
21195 result = 0;
21196 }
21197 }
21198 if (Z_TYPE_P(offset) == IS_LONG) {
21199 if (opline->extended_value & ZEND_ISSET) {
21200 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
21201 result = 1;
21202 }
21203 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
21204 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
21205 result = 1;
21206 }
21207 }
21208 }
21209 zval_ptr_dtor_nogc(&free_op2.var);
21210 } else {
21211 zval_ptr_dtor_nogc(&free_op2.var);
21212 }
21213
21214 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
21215 if (opline->extended_value & ZEND_ISSET) {
21216 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
21217 } else {
21218 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
21219 }
21220
21221 zval_ptr_dtor_nogc(&free_op1.var);
21222
21223 CHECK_EXCEPTION();
21224 ZEND_VM_NEXT_OPCODE();
21225 }
21226
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21227 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21228 {
21229 return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21230 }
21231
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21232 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21233 {
21234 return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21235 }
21236
ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21237 static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21238 {
21239 USE_OPLINE
21240
21241 /* The generator object is stored in return_value_ptr_ptr */
21242 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
21243
21244 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
21245 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
21246 }
21247
21248 /* Destroy the previously yielded value */
21249 if (generator->value) {
21250 zval_ptr_dtor(&generator->value);
21251 }
21252
21253 /* Destroy the previously yielded key */
21254 if (generator->key) {
21255 zval_ptr_dtor(&generator->key);
21256 }
21257
21258 /* Set the new yielded value */
21259 if (IS_VAR != IS_UNUSED) {
21260 zend_free_op free_op1;
21261
21262 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
21263 /* Constants and temporary variables aren't yieldable by reference,
21264 * but we still allow them with a notice. */
21265 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
21266 zval *value, *copy;
21267
21268 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21269
21270 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21271 ALLOC_ZVAL(copy);
21272 INIT_PZVAL_COPY(copy, value);
21273
21274 /* Temporary variables don't need ctor copying */
21275 if (!0) {
21276 zval_copy_ctor(copy);
21277 }
21278
21279 generator->value = copy;
21280 } else {
21281 zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21282
21283 if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
21284 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
21285 }
21286
21287 /* If a function call result is yielded and the function did
21288 * not return by reference we throw a notice. */
21289 if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
21290 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
21291 && EX_T(opline->op1.var).var.fcall_returned_reference)
21292 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
21293 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21294
21295 Z_ADDREF_PP(value_ptr);
21296 generator->value = *value_ptr;
21297 } else {
21298 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
21299 Z_ADDREF_PP(value_ptr);
21300 generator->value = *value_ptr;
21301 }
21302
21303 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21304 }
21305 } else {
21306 zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21307
21308 /* Consts, temporary variables and references need copying */
21309 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
21310 || PZVAL_IS_REF(value)
21311 ) {
21312 zval *copy;
21313
21314 ALLOC_ZVAL(copy);
21315 INIT_PZVAL_COPY(copy, value);
21316
21317 /* Temporary variables don't need ctor copying */
21318 if (!0) {
21319 zval_copy_ctor(copy);
21320 }
21321
21322 generator->value = copy;
21323 zval_ptr_dtor_nogc(&free_op1.var);
21324 } else {
21325 if (IS_VAR == IS_CV) {
21326 Z_ADDREF_P(value);
21327 }
21328 generator->value = value;
21329 }
21330 }
21331 } else {
21332 /* If no value was specified yield null */
21333 Z_ADDREF(EG(uninitialized_zval));
21334 generator->value = &EG(uninitialized_zval);
21335 }
21336
21337 /* Set the new yielded key */
21338 if (IS_VAR != IS_UNUSED) {
21339 zend_free_op free_op2;
21340 zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
21341
21342 /* Consts, temporary variables and references need copying */
21343 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
21344 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
21345 ) {
21346 zval *copy;
21347
21348 ALLOC_ZVAL(copy);
21349 INIT_PZVAL_COPY(copy, key);
21350
21351 /* Temporary variables don't need ctor copying */
21352 if (!0) {
21353 zval_copy_ctor(copy);
21354 }
21355
21356 generator->key = copy;
21357 } else {
21358 Z_ADDREF_P(key);
21359 generator->key = key;
21360 }
21361
21362 if (Z_TYPE_P(generator->key) == IS_LONG
21363 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
21364 ) {
21365 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
21366 }
21367
21368 zval_ptr_dtor_nogc(&free_op2.var);
21369 } else {
21370 /* If no key was specified we use auto-increment keys */
21371 generator->largest_used_integer_key++;
21372
21373 ALLOC_INIT_ZVAL(generator->key);
21374 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
21375 }
21376
21377 if (RETURN_VALUE_USED(opline)) {
21378 /* If the return value of yield is used set the send
21379 * target and initialize it to NULL */
21380 generator->send_target = &EX_T(opline->result.var).var.ptr;
21381 Z_ADDREF(EG(uninitialized_zval));
21382 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21383 } else {
21384 generator->send_target = NULL;
21385 }
21386
21387 /* We increment to the next op, so we are at the correct position when the
21388 * generator is resumed. */
21389 ZEND_VM_INC_OPCODE();
21390
21391 /* The GOTO VM uses a local opline variable. We need to set the opline
21392 * variable in execute_data so we don't resume at an old position. */
21393 SAVE_OPLINE();
21394
21395 ZEND_VM_RETURN();
21396 }
21397
ZEND_POW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21398 static int ZEND_FASTCALL ZEND_POW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21399 {
21400 USE_OPLINE
21401 zend_free_op free_op1, free_op2;
21402
21403 SAVE_OPLINE();
21404 pow_function(&EX_T(opline->result.var).tmp_var,
21405 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
21406 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
21407 zval_ptr_dtor_nogc(&free_op1.var);
21408 zval_ptr_dtor_nogc(&free_op2.var);
21409 CHECK_EXCEPTION();
21410 ZEND_VM_NEXT_OPCODE();
21411 }
21412
ZEND_ASSIGN_POW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21413 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21414 {
21415 return zend_binary_assign_op_helper_SPEC_VAR_VAR(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21416 }
21417
zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)21418 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
21419 {
21420 USE_OPLINE
21421 zend_free_op free_op1, free_op_data1;
21422 zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21423 zval *object;
21424 zval *property = NULL;
21425 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
21426 int have_get_ptr = 0;
21427
21428 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
21429 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
21430 }
21431
21432 make_real_object(object_ptr TSRMLS_CC);
21433 object = *object_ptr;
21434
21435 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
21436 zend_error(E_WARNING, "Attempt to assign property of non-object");
21437
21438 FREE_OP(free_op_data1);
21439
21440 if (RETURN_VALUE_USED(opline)) {
21441 PZVAL_LOCK(&EG(uninitialized_zval));
21442 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21443 }
21444 } else {
21445 /* here we are sure we are dealing with an object */
21446 if (0) {
21447 MAKE_REAL_ZVAL_PTR(property);
21448 }
21449
21450 /* here property is a string */
21451 if (opline->extended_value == ZEND_ASSIGN_OBJ
21452 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
21453 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
21454 if (zptr != NULL) { /* NULL means no success in getting PTR */
21455 have_get_ptr = 1;
21456 if (UNEXPECTED(*zptr == &EG(error_zval))) {
21457 if (RETURN_VALUE_USED(opline)) {
21458 PZVAL_LOCK(&EG(uninitialized_zval));
21459 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21460 }
21461 } else {
21462 SEPARATE_ZVAL_IF_NOT_REF(zptr);
21463
21464 binary_op(*zptr, *zptr, value TSRMLS_CC);
21465 if (RETURN_VALUE_USED(opline)) {
21466 PZVAL_LOCK(*zptr);
21467 EX_T(opline->result.var).var.ptr = *zptr;
21468 }
21469 }
21470 }
21471 }
21472
21473 if (!have_get_ptr) {
21474 zval *z = NULL;
21475
21476 Z_ADDREF_P(object);
21477 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
21478 if (Z_OBJ_HT_P(object)->read_property) {
21479 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
21480 }
21481 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
21482 if (Z_OBJ_HT_P(object)->read_dimension) {
21483 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
21484 }
21485 }
21486 if (z) {
21487 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
21488 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
21489
21490 if (Z_REFCOUNT_P(z) == 0) {
21491 GC_REMOVE_ZVAL_FROM_BUFFER(z);
21492 zval_dtor(z);
21493 FREE_ZVAL(z);
21494 }
21495 z = value;
21496 }
21497 Z_ADDREF_P(z);
21498 SEPARATE_ZVAL_IF_NOT_REF(&z);
21499 binary_op(z, z, value TSRMLS_CC);
21500 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
21501 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
21502 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
21503 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
21504 }
21505 if (RETURN_VALUE_USED(opline)) {
21506 PZVAL_LOCK(z);
21507 EX_T(opline->result.var).var.ptr = z;
21508 }
21509 zval_ptr_dtor(&z);
21510 } else {
21511 zend_error(E_WARNING, "Attempt to assign property of non-object");
21512 if (RETURN_VALUE_USED(opline)) {
21513 PZVAL_LOCK(&EG(uninitialized_zval));
21514 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21515 }
21516 }
21517 zval_ptr_dtor(&object);
21518 }
21519
21520 if (0) {
21521 zval_ptr_dtor(&property);
21522 } else {
21523
21524 }
21525 FREE_OP(free_op_data1);
21526 }
21527
21528 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21529 /* assign_obj has two opcodes! */
21530 CHECK_EXCEPTION();
21531 ZEND_VM_INC_OPCODE();
21532 ZEND_VM_NEXT_OPCODE();
21533 }
21534
zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)21535 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
21536 {
21537 USE_OPLINE
21538 zend_free_op free_op1, free_op_data2, free_op_data1;
21539 zval **var_ptr;
21540 zval *value;
21541
21542 SAVE_OPLINE();
21543 switch (opline->extended_value) {
21544 case ZEND_ASSIGN_OBJ:
21545 return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21546 break;
21547 case ZEND_ASSIGN_DIM: {
21548 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21549
21550 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
21551 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21552 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
21553 if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
21554 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
21555 }
21556 return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21557 } else {
21558 zval *dim = NULL;
21559
21560 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
21561 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
21562 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
21563 }
21564 }
21565 break;
21566 default:
21567 value = NULL;
21568 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21569 /* do nothing */
21570 break;
21571 }
21572
21573 if (UNEXPECTED(var_ptr == NULL)) {
21574 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
21575 }
21576
21577 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
21578 if (RETURN_VALUE_USED(opline)) {
21579 PZVAL_LOCK(&EG(uninitialized_zval));
21580 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21581 }
21582
21583 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21584 CHECK_EXCEPTION();
21585 if (opline->extended_value == ZEND_ASSIGN_DIM) {
21586 ZEND_VM_INC_OPCODE();
21587 }
21588 ZEND_VM_NEXT_OPCODE();
21589 }
21590
21591 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
21592
21593 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
21594 && Z_OBJ_HANDLER_PP(var_ptr, get)
21595 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
21596 /* proxy object */
21597 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
21598 Z_ADDREF_P(objval);
21599 binary_op(objval, objval, value TSRMLS_CC);
21600 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
21601 zval_ptr_dtor(&objval);
21602 } else {
21603 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
21604 }
21605
21606 if (RETURN_VALUE_USED(opline)) {
21607 PZVAL_LOCK(*var_ptr);
21608 EX_T(opline->result.var).var.ptr = *var_ptr;
21609 }
21610
21611 if (opline->extended_value == ZEND_ASSIGN_DIM) {
21612 FREE_OP(free_op_data1);
21613 FREE_OP_VAR_PTR(free_op_data2);
21614 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21615 CHECK_EXCEPTION();
21616 ZEND_VM_INC_OPCODE();
21617 } else {
21618 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21619 CHECK_EXCEPTION();
21620 }
21621 ZEND_VM_NEXT_OPCODE();
21622 }
21623
ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21624 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21625 {
21626 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21627 }
21628
ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21629 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21630 {
21631 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21632 }
21633
ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21634 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21635 {
21636 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21637 }
21638
ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21639 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21640 {
21641 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21642 }
21643
ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21644 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21645 {
21646 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21647 }
21648
ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21649 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21650 {
21651 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21652 }
21653
ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21654 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21655 {
21656 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21657 }
21658
ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21659 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21660 {
21661 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21662 }
21663
ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21664 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21665 {
21666 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21667 }
21668
ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21669 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21670 {
21671 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21672 }
21673
ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21674 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21675 {
21676 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21677 }
21678
zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,ZEND_OPCODE_HANDLER_ARGS)21679 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
21680 {
21681 USE_OPLINE
21682 zend_free_op free_op1;
21683 zval *varname;
21684 zval **retval;
21685 zval tmp_varname;
21686 HashTable *target_symbol_table;
21687 ulong hash_value;
21688
21689 SAVE_OPLINE();
21690 varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21691
21692 if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
21693 ZVAL_COPY_VALUE(&tmp_varname, varname);
21694 zval_copy_ctor(&tmp_varname);
21695 Z_SET_REFCOUNT(tmp_varname, 1);
21696 Z_UNSET_ISREF(tmp_varname);
21697 convert_to_string(&tmp_varname);
21698 varname = &tmp_varname;
21699 }
21700
21701 if (IS_UNUSED != IS_UNUSED) {
21702 zend_class_entry *ce;
21703
21704 if (IS_UNUSED == IS_CONST) {
21705 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
21706 ce = CACHED_PTR(opline->op2.literal->cache_slot);
21707 } else {
21708 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
21709 if (UNEXPECTED(ce == NULL)) {
21710 if (IS_VAR != IS_CONST && varname == &tmp_varname) {
21711 zval_dtor(&tmp_varname);
21712 }
21713 zval_ptr_dtor_nogc(&free_op1.var);
21714 CHECK_EXCEPTION();
21715 ZEND_VM_NEXT_OPCODE();
21716 }
21717 CACHE_PTR(opline->op2.literal->cache_slot, ce);
21718 }
21719 } else {
21720 ce = EX_T(opline->op2.var).class_entry;
21721 }
21722 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
21723 zval_ptr_dtor_nogc(&free_op1.var);
21724 } else {
21725 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
21726 /*
21727 if (!target_symbol_table) {
21728 CHECK_EXCEPTION();
21729 ZEND_VM_NEXT_OPCODE();
21730 }
21731 */
21732 if (IS_VAR == IS_CONST) {
21733 hash_value = Z_HASH_P(varname);
21734 } else {
21735 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
21736 }
21737
21738 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
21739 switch (type) {
21740 case BP_VAR_R:
21741 case BP_VAR_UNSET:
21742 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
21743 /* break missing intentionally */
21744 case BP_VAR_IS:
21745 retval = &EG(uninitialized_zval_ptr);
21746 break;
21747 case BP_VAR_RW:
21748 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
21749 /* break missing intentionally */
21750 case BP_VAR_W:
21751 Z_ADDREF_P(&EG(uninitialized_zval));
21752 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
21753 break;
21754 EMPTY_SWITCH_DEFAULT_CASE()
21755 }
21756 }
21757 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
21758 case ZEND_FETCH_GLOBAL:
21759 if (IS_VAR != IS_TMP_VAR) {
21760 zval_ptr_dtor_nogc(&free_op1.var);
21761 }
21762 break;
21763 case ZEND_FETCH_LOCAL:
21764 zval_ptr_dtor_nogc(&free_op1.var);
21765 break;
21766 case ZEND_FETCH_STATIC:
21767 zval_update_constant(retval, 1 TSRMLS_CC);
21768 break;
21769 case ZEND_FETCH_GLOBAL_LOCK:
21770 if (IS_VAR == IS_VAR && !free_op1.var) {
21771 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
21772 }
21773 break;
21774 }
21775 }
21776
21777
21778 if (IS_VAR != IS_CONST && varname == &tmp_varname) {
21779 zval_dtor(&tmp_varname);
21780 }
21781 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
21782 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
21783 }
21784 PZVAL_LOCK(*retval);
21785 switch (type) {
21786 case BP_VAR_R:
21787 case BP_VAR_IS:
21788 EX_T(opline->result.var).var.ptr = *retval;
21789 break;
21790 case BP_VAR_UNSET: {
21791 zend_free_op free_res;
21792
21793 PZVAL_UNLOCK(*retval, &free_res);
21794 if (retval != &EG(uninitialized_zval_ptr)) {
21795 SEPARATE_ZVAL_IF_NOT_REF(retval);
21796 }
21797 PZVAL_LOCK(*retval);
21798 FREE_OP_VAR_PTR(free_res);
21799 }
21800 /* break missing intentionally */
21801 default:
21802 EX_T(opline->result.var).var.ptr_ptr = retval;
21803 break;
21804 }
21805 CHECK_EXCEPTION();
21806 ZEND_VM_NEXT_OPCODE();
21807 }
21808
ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21809 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21810 {
21811 return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21812 }
21813
ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21814 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21815 {
21816 return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21817 }
21818
ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21819 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21820 {
21821 return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21822 }
21823
ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21824 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21825 {
21826 USE_OPLINE
21827
21828 return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21829 }
21830
ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21831 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21832 {
21833 return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21834 }
21835
ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21836 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21837 {
21838 return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21839 }
21840
ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21841 static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21842 {
21843 USE_OPLINE
21844 zend_free_op free_op1;
21845 zval **container;
21846
21847 SAVE_OPLINE();
21848 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21849
21850 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
21851 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21852 }
21853 zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
21854
21855 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
21856 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
21857 }
21858 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21859
21860 /* We are going to assign the result by reference */
21861 if (UNEXPECTED(opline->extended_value != 0)) {
21862 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
21863
21864 if (retval_ptr) {
21865 Z_DELREF_PP(retval_ptr);
21866 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
21867 Z_ADDREF_PP(retval_ptr);
21868 }
21869 }
21870
21871 CHECK_EXCEPTION();
21872 ZEND_VM_NEXT_OPCODE();
21873 }
21874
ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21875 static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21876 {
21877 USE_OPLINE
21878 zend_free_op free_op1;
21879 zval **container;
21880
21881 SAVE_OPLINE();
21882 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21883
21884 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
21885 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21886 }
21887 zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
21888
21889 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
21890 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
21891 }
21892 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21893 CHECK_EXCEPTION();
21894 ZEND_VM_NEXT_OPCODE();
21895 }
21896
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21897 static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21898 {
21899 USE_OPLINE
21900 zend_free_op free_op1;
21901
21902 SAVE_OPLINE();
21903
21904 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
21905 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21906 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
21907 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21908 }
21909 zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
21910 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
21911 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
21912 }
21913
21914 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21915 } else {
21916 zval *container;
21917
21918 if (IS_UNUSED == IS_UNUSED) {
21919 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
21920 }
21921 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21922 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC);
21923
21924 zval_ptr_dtor_nogc(&free_op1.var);
21925 }
21926 CHECK_EXCEPTION();
21927 ZEND_VM_NEXT_OPCODE();
21928 }
21929
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21930 static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21931 {
21932 USE_OPLINE
21933 zend_free_op free_op1;
21934 zval **object_ptr;
21935
21936 SAVE_OPLINE();
21937 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21938
21939 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
21940 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21941 }
21942 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
21943
21944 zval *property_name = NULL;
21945
21946 if (0) {
21947 MAKE_REAL_ZVAL_PTR(property_name);
21948 }
21949 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
21950 if (0) {
21951 zval_ptr_dtor(&property_name);
21952 } else {
21953
21954 }
21955 } else {
21956 zend_free_op free_op_data1, free_op_data2;
21957 zval *value;
21958 zval *dim = NULL;
21959 zval **variable_ptr_ptr;
21960
21961 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC);
21962
21963 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
21964 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
21965 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
21966 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
21967 if (RETURN_VALUE_USED(opline)) {
21968 zval *retval;
21969
21970 ALLOC_ZVAL(retval);
21971 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
21972 INIT_PZVAL(retval);
21973 EX_T(opline->result.var).var.ptr = retval;
21974 }
21975 } else if (RETURN_VALUE_USED(opline)) {
21976 PZVAL_LOCK(&EG(uninitialized_zval));
21977 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21978 }
21979 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
21980 if (IS_TMP_FREE(free_op_data1)) {
21981 zval_dtor(value);
21982 }
21983 if (RETURN_VALUE_USED(opline)) {
21984 PZVAL_LOCK(&EG(uninitialized_zval));
21985 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21986 }
21987 } else {
21988 if ((opline+1)->op1_type == IS_TMP_VAR) {
21989 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
21990 } else if ((opline+1)->op1_type == IS_CONST) {
21991 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
21992 } else {
21993 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
21994 }
21995 if (RETURN_VALUE_USED(opline)) {
21996 PZVAL_LOCK(value);
21997 EX_T(opline->result.var).var.ptr = value;
21998 }
21999 }
22000 FREE_OP_VAR_PTR(free_op_data2);
22001 FREE_OP_IF_VAR(free_op_data1);
22002 }
22003 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
22004 /* assign_dim has two opcodes! */
22005 CHECK_EXCEPTION();
22006 ZEND_VM_INC_OPCODE();
22007 ZEND_VM_NEXT_OPCODE();
22008 }
22009
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22010 static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22011 {
22012 USE_OPLINE
22013 zval *function_name;
22014 zend_class_entry *ce;
22015 call_slot *call = EX(call_slots) + opline->result.num;
22016
22017 SAVE_OPLINE();
22018
22019 if (IS_VAR == IS_CONST) {
22020 /* no function found. try a static method in class */
22021 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
22022 ce = CACHED_PTR(opline->op1.literal->cache_slot);
22023 } else {
22024 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
22025 if (UNEXPECTED(EG(exception) != NULL)) {
22026 HANDLE_EXCEPTION();
22027 }
22028 if (UNEXPECTED(ce == NULL)) {
22029 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
22030 }
22031 CACHE_PTR(opline->op1.literal->cache_slot, ce);
22032 }
22033 call->called_scope = ce;
22034 } else {
22035 ce = EX_T(opline->op1.var).class_entry;
22036
22037 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
22038 call->called_scope = EG(called_scope);
22039 } else {
22040 call->called_scope = ce;
22041 }
22042 }
22043
22044 if (IS_VAR == IS_CONST &&
22045 IS_UNUSED == IS_CONST &&
22046 CACHED_PTR(opline->op2.literal->cache_slot)) {
22047 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
22048 } else if (IS_VAR != IS_CONST &&
22049 IS_UNUSED == IS_CONST &&
22050 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
22051 /* do nothing */
22052 } else if (IS_UNUSED != IS_UNUSED) {
22053 char *function_name_strval = NULL;
22054 int function_name_strlen = 0;
22055
22056
22057 if (IS_UNUSED == IS_CONST) {
22058 function_name_strval = Z_STRVAL_P(opline->op2.zv);
22059 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
22060 } else {
22061 function_name = NULL;
22062
22063 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
22064 if (UNEXPECTED(EG(exception) != NULL)) {
22065 HANDLE_EXCEPTION();
22066 }
22067 zend_error_noreturn(E_ERROR, "Function name must be a string");
22068 } else {
22069 function_name_strval = Z_STRVAL_P(function_name);
22070 function_name_strlen = Z_STRLEN_P(function_name);
22071 }
22072 }
22073
22074 if (function_name_strval) {
22075 if (ce->get_static_method) {
22076 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
22077 } else {
22078 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
22079 }
22080 if (UNEXPECTED(call->fbc == NULL)) {
22081 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
22082 }
22083 if (IS_UNUSED == IS_CONST &&
22084 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
22085 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
22086 if (IS_VAR == IS_CONST) {
22087 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
22088 } else {
22089 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
22090 }
22091 }
22092 }
22093 if (IS_UNUSED != IS_CONST) {
22094
22095 }
22096 } else {
22097 if (UNEXPECTED(ce->constructor == NULL)) {
22098 zend_error_noreturn(E_ERROR, "Cannot call constructor");
22099 }
22100 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
22101 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
22102 }
22103 call->fbc = ce->constructor;
22104 }
22105
22106 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
22107 call->object = NULL;
22108 } else {
22109 if (EG(This) &&
22110 Z_OBJ_HT_P(EG(This))->get_class_entry &&
22111 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
22112 /* We are calling method of the other (incompatible) class,
22113 but passing $this. This is done for compatibility with php-4. */
22114 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
22115 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
22116 } else {
22117 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
22118 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
22119 }
22120 }
22121 if ((call->object = EG(This))) {
22122 Z_ADDREF_P(call->object);
22123 call->called_scope = Z_OBJCE_P(call->object);
22124 }
22125 }
22126
22127 call->num_additional_args = 0;
22128 call->is_ctor_call = 0;
22129 EX(call) = call;
22130
22131 CHECK_EXCEPTION();
22132 ZEND_VM_NEXT_OPCODE();
22133 }
22134
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22135 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22136 {
22137 USE_OPLINE
22138 zend_free_op free_op1;
22139 zval *expr_ptr;
22140
22141 SAVE_OPLINE();
22142 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
22143 zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22144
22145 if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
22146 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
22147 }
22148 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
22149 expr_ptr = *expr_ptr_ptr;
22150 Z_ADDREF_P(expr_ptr);
22151 } else {
22152 expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22153 if (0) { /* temporary variable */
22154 zval *new_expr;
22155
22156 ALLOC_ZVAL(new_expr);
22157 INIT_PZVAL_COPY(new_expr, expr_ptr);
22158 expr_ptr = new_expr;
22159 } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
22160 zval *new_expr;
22161
22162 ALLOC_ZVAL(new_expr);
22163 INIT_PZVAL_COPY(new_expr, expr_ptr);
22164 expr_ptr = new_expr;
22165 zendi_zval_copy_ctor(*expr_ptr);
22166 zval_ptr_dtor_nogc(&free_op1.var);
22167 } else if (IS_VAR == IS_CV) {
22168 Z_ADDREF_P(expr_ptr);
22169 }
22170 }
22171
22172 if (IS_UNUSED != IS_UNUSED) {
22173
22174 zval *offset = NULL;
22175 ulong hval;
22176
22177 switch (Z_TYPE_P(offset)) {
22178 case IS_DOUBLE:
22179 hval = zend_dval_to_lval(Z_DVAL_P(offset));
22180 goto num_index;
22181 case IS_LONG:
22182 case IS_BOOL:
22183 hval = Z_LVAL_P(offset);
22184 num_index:
22185 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
22186 break;
22187 case IS_STRING:
22188 if (IS_UNUSED == IS_CONST) {
22189 hval = Z_HASH_P(offset);
22190 } else {
22191 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
22192 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
22193 }
22194 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
22195 break;
22196 case IS_NULL:
22197 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
22198 break;
22199 default:
22200 zend_error(E_WARNING, "Illegal offset type");
22201 zval_ptr_dtor(&expr_ptr);
22202 /* do nothing */
22203 break;
22204 }
22205
22206 } else {
22207 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
22208 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
22209 zval_ptr_dtor(&expr_ptr);
22210 }
22211 }
22212 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
22213 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
22214 }
22215 CHECK_EXCEPTION();
22216 ZEND_VM_NEXT_OPCODE();
22217 }
22218
ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22219 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22220 {
22221 USE_OPLINE
22222
22223 array_init(&EX_T(opline->result.var).tmp_var);
22224 if (IS_VAR == IS_UNUSED) {
22225 ZEND_VM_NEXT_OPCODE();
22226 #if 0 || IS_VAR != IS_UNUSED
22227 } else {
22228 return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22229 #endif
22230 }
22231 }
22232
ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22233 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22234 {
22235 USE_OPLINE
22236 zval tmp, *varname;
22237 HashTable *target_symbol_table;
22238 zend_free_op free_op1;
22239
22240 SAVE_OPLINE();
22241 if (IS_VAR == IS_CV &&
22242 IS_UNUSED == IS_UNUSED &&
22243 (opline->extended_value & ZEND_QUICK_SET)) {
22244 if (EG(active_symbol_table)) {
22245 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
22246
22247 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
22248 EX_CV(opline->op1.var) = NULL;
22249 } else if (EX_CV(opline->op1.var)) {
22250 zval_ptr_dtor(EX_CV(opline->op1.var));
22251 EX_CV(opline->op1.var) = NULL;
22252 }
22253 CHECK_EXCEPTION();
22254 ZEND_VM_NEXT_OPCODE();
22255 }
22256
22257 varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22258
22259 if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
22260 ZVAL_COPY_VALUE(&tmp, varname);
22261 zval_copy_ctor(&tmp);
22262 convert_to_string(&tmp);
22263 varname = &tmp;
22264 } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22265 Z_ADDREF_P(varname);
22266 }
22267
22268 if (IS_UNUSED != IS_UNUSED) {
22269 zend_class_entry *ce;
22270
22271 if (IS_UNUSED == IS_CONST) {
22272 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
22273 ce = CACHED_PTR(opline->op2.literal->cache_slot);
22274 } else {
22275 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
22276 if (UNEXPECTED(EG(exception) != NULL)) {
22277 if (IS_VAR != IS_CONST && varname == &tmp) {
22278 zval_dtor(&tmp);
22279 } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22280 zval_ptr_dtor(&varname);
22281 }
22282 zval_ptr_dtor_nogc(&free_op1.var);
22283 HANDLE_EXCEPTION();
22284 }
22285 if (UNEXPECTED(ce == NULL)) {
22286 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
22287 }
22288 CACHE_PTR(opline->op2.literal->cache_slot, ce);
22289 }
22290 } else {
22291 ce = EX_T(opline->op2.var).class_entry;
22292 }
22293 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
22294 } else {
22295 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
22296
22297 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
22298 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
22299 }
22300
22301 if (IS_VAR != IS_CONST && varname == &tmp) {
22302 zval_dtor(&tmp);
22303 } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22304 zval_ptr_dtor(&varname);
22305 }
22306 zval_ptr_dtor_nogc(&free_op1.var);
22307 CHECK_EXCEPTION();
22308 ZEND_VM_NEXT_OPCODE();
22309 }
22310
ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22311 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22312 {
22313 USE_OPLINE
22314 zval **value;
22315 zend_bool isset = 1;
22316
22317 SAVE_OPLINE();
22318 if (IS_VAR == IS_CV &&
22319 IS_UNUSED == IS_UNUSED &&
22320 (opline->extended_value & ZEND_QUICK_SET)) {
22321 if (EX_CV(opline->op1.var)) {
22322 value = EX_CV(opline->op1.var);
22323 } else if (EG(active_symbol_table)) {
22324 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
22325
22326 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
22327 isset = 0;
22328 }
22329 } else {
22330 isset = 0;
22331 }
22332 } else {
22333 HashTable *target_symbol_table;
22334 zend_free_op free_op1;
22335 zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22336
22337 if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
22338 ZVAL_COPY_VALUE(&tmp, varname);
22339 zval_copy_ctor(&tmp);
22340 convert_to_string(&tmp);
22341 varname = &tmp;
22342 }
22343
22344 if (IS_UNUSED != IS_UNUSED) {
22345 zend_class_entry *ce;
22346
22347 if (IS_UNUSED == IS_CONST) {
22348 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
22349 ce = CACHED_PTR(opline->op2.literal->cache_slot);
22350 } else {
22351 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
22352 if (UNEXPECTED(ce == NULL)) {
22353 CHECK_EXCEPTION();
22354 ZEND_VM_NEXT_OPCODE();
22355 }
22356 CACHE_PTR(opline->op2.literal->cache_slot, ce);
22357 }
22358 } else {
22359 ce = EX_T(opline->op2.var).class_entry;
22360 }
22361 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
22362 if (!value) {
22363 isset = 0;
22364 }
22365 } else {
22366 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
22367 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
22368 isset = 0;
22369 }
22370 }
22371
22372 if (IS_VAR != IS_CONST && varname == &tmp) {
22373 zval_dtor(&tmp);
22374 }
22375 zval_ptr_dtor_nogc(&free_op1.var);
22376 }
22377
22378 if (opline->extended_value & ZEND_ISSET) {
22379 if (isset && Z_TYPE_PP(value) != IS_NULL) {
22380 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
22381 } else {
22382 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
22383 }
22384 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
22385 if (!isset || !i_zend_is_true(*value)) {
22386 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
22387 } else {
22388 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
22389 }
22390 }
22391
22392 CHECK_EXCEPTION();
22393 ZEND_VM_NEXT_OPCODE();
22394 }
22395
ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22396 static int ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22397 {
22398 USE_OPLINE
22399 zval *var_ptr, *new_zv;
22400
22401 SAVE_OPLINE();
22402 var_ptr = EX_T(opline->op1.var).var.ptr;
22403 if (Z_TYPE_P(var_ptr) != IS_OBJECT &&
22404 !PZVAL_IS_REF(var_ptr) &&
22405 Z_REFCOUNT_P(var_ptr) > 1) {
22406
22407 Z_DELREF_P(var_ptr);
22408 ALLOC_ZVAL(new_zv);
22409 INIT_PZVAL_COPY(new_zv, var_ptr);
22410 var_ptr = new_zv;
22411 zval_copy_ctor(var_ptr);
22412 EX_T(opline->op1.var).var.ptr = var_ptr;
22413 }
22414 ZEND_VM_NEXT_OPCODE();
22415 }
22416
ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22417 static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22418 {
22419 USE_OPLINE
22420
22421 /* The generator object is stored in return_value_ptr_ptr */
22422 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
22423
22424 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
22425 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
22426 }
22427
22428 /* Destroy the previously yielded value */
22429 if (generator->value) {
22430 zval_ptr_dtor(&generator->value);
22431 }
22432
22433 /* Destroy the previously yielded key */
22434 if (generator->key) {
22435 zval_ptr_dtor(&generator->key);
22436 }
22437
22438 /* Set the new yielded value */
22439 if (IS_VAR != IS_UNUSED) {
22440 zend_free_op free_op1;
22441
22442 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
22443 /* Constants and temporary variables aren't yieldable by reference,
22444 * but we still allow them with a notice. */
22445 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
22446 zval *value, *copy;
22447
22448 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22449
22450 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22451 ALLOC_ZVAL(copy);
22452 INIT_PZVAL_COPY(copy, value);
22453
22454 /* Temporary variables don't need ctor copying */
22455 if (!0) {
22456 zval_copy_ctor(copy);
22457 }
22458
22459 generator->value = copy;
22460 } else {
22461 zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22462
22463 if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
22464 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
22465 }
22466
22467 /* If a function call result is yielded and the function did
22468 * not return by reference we throw a notice. */
22469 if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
22470 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
22471 && EX_T(opline->op1.var).var.fcall_returned_reference)
22472 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
22473 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22474
22475 Z_ADDREF_PP(value_ptr);
22476 generator->value = *value_ptr;
22477 } else {
22478 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
22479 Z_ADDREF_PP(value_ptr);
22480 generator->value = *value_ptr;
22481 }
22482
22483 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
22484 }
22485 } else {
22486 zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22487
22488 /* Consts, temporary variables and references need copying */
22489 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
22490 || PZVAL_IS_REF(value)
22491 ) {
22492 zval *copy;
22493
22494 ALLOC_ZVAL(copy);
22495 INIT_PZVAL_COPY(copy, value);
22496
22497 /* Temporary variables don't need ctor copying */
22498 if (!0) {
22499 zval_copy_ctor(copy);
22500 }
22501
22502 generator->value = copy;
22503 zval_ptr_dtor_nogc(&free_op1.var);
22504 } else {
22505 if (IS_VAR == IS_CV) {
22506 Z_ADDREF_P(value);
22507 }
22508 generator->value = value;
22509 }
22510 }
22511 } else {
22512 /* If no value was specified yield null */
22513 Z_ADDREF(EG(uninitialized_zval));
22514 generator->value = &EG(uninitialized_zval);
22515 }
22516
22517 /* Set the new yielded key */
22518 if (IS_UNUSED != IS_UNUSED) {
22519
22520 zval *key = NULL;
22521
22522 /* Consts, temporary variables and references need copying */
22523 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
22524 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
22525 ) {
22526 zval *copy;
22527
22528 ALLOC_ZVAL(copy);
22529 INIT_PZVAL_COPY(copy, key);
22530
22531 /* Temporary variables don't need ctor copying */
22532 if (!0) {
22533 zval_copy_ctor(copy);
22534 }
22535
22536 generator->key = copy;
22537 } else {
22538 Z_ADDREF_P(key);
22539 generator->key = key;
22540 }
22541
22542 if (Z_TYPE_P(generator->key) == IS_LONG
22543 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
22544 ) {
22545 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
22546 }
22547
22548 } else {
22549 /* If no key was specified we use auto-increment keys */
22550 generator->largest_used_integer_key++;
22551
22552 ALLOC_INIT_ZVAL(generator->key);
22553 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
22554 }
22555
22556 if (RETURN_VALUE_USED(opline)) {
22557 /* If the return value of yield is used set the send
22558 * target and initialize it to NULL */
22559 generator->send_target = &EX_T(opline->result.var).var.ptr;
22560 Z_ADDREF(EG(uninitialized_zval));
22561 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
22562 } else {
22563 generator->send_target = NULL;
22564 }
22565
22566 /* We increment to the next op, so we are at the correct position when the
22567 * generator is resumed. */
22568 ZEND_VM_INC_OPCODE();
22569
22570 /* The GOTO VM uses a local opline variable. We need to set the opline
22571 * variable in execute_data so we don't resume at an old position. */
22572 SAVE_OPLINE();
22573
22574 ZEND_VM_RETURN();
22575 }
22576
ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22577 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22578 {
22579 return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22580 }
22581
ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22582 static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22583 {
22584 USE_OPLINE
22585 zend_free_op free_op1;
22586
22587 SAVE_OPLINE();
22588 fast_add_function(&EX_T(opline->result.var).tmp_var,
22589 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22590 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22591 zval_ptr_dtor_nogc(&free_op1.var);
22592
22593 CHECK_EXCEPTION();
22594 ZEND_VM_NEXT_OPCODE();
22595 }
22596
ZEND_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22597 static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22598 {
22599 USE_OPLINE
22600 zend_free_op free_op1;
22601
22602 SAVE_OPLINE();
22603 fast_sub_function(&EX_T(opline->result.var).tmp_var,
22604 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22605 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22606 zval_ptr_dtor_nogc(&free_op1.var);
22607
22608 CHECK_EXCEPTION();
22609 ZEND_VM_NEXT_OPCODE();
22610 }
22611
ZEND_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22612 static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22613 {
22614 USE_OPLINE
22615 zend_free_op free_op1;
22616
22617 SAVE_OPLINE();
22618 fast_mul_function(&EX_T(opline->result.var).tmp_var,
22619 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22620 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22621 zval_ptr_dtor_nogc(&free_op1.var);
22622
22623 CHECK_EXCEPTION();
22624 ZEND_VM_NEXT_OPCODE();
22625 }
22626
ZEND_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22627 static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22628 {
22629 USE_OPLINE
22630 zend_free_op free_op1;
22631
22632 SAVE_OPLINE();
22633 fast_div_function(&EX_T(opline->result.var).tmp_var,
22634 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22635 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22636 zval_ptr_dtor_nogc(&free_op1.var);
22637
22638 CHECK_EXCEPTION();
22639 ZEND_VM_NEXT_OPCODE();
22640 }
22641
ZEND_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22642 static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22643 {
22644 USE_OPLINE
22645 zend_free_op free_op1;
22646
22647 SAVE_OPLINE();
22648 fast_mod_function(&EX_T(opline->result.var).tmp_var,
22649 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22650 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22651 zval_ptr_dtor_nogc(&free_op1.var);
22652
22653 CHECK_EXCEPTION();
22654 ZEND_VM_NEXT_OPCODE();
22655 }
22656
ZEND_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22657 static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22658 {
22659 USE_OPLINE
22660 zend_free_op free_op1;
22661
22662 SAVE_OPLINE();
22663 shift_left_function(&EX_T(opline->result.var).tmp_var,
22664 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22665 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22666 zval_ptr_dtor_nogc(&free_op1.var);
22667
22668 CHECK_EXCEPTION();
22669 ZEND_VM_NEXT_OPCODE();
22670 }
22671
ZEND_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22672 static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22673 {
22674 USE_OPLINE
22675 zend_free_op free_op1;
22676
22677 SAVE_OPLINE();
22678 shift_right_function(&EX_T(opline->result.var).tmp_var,
22679 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22680 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22681 zval_ptr_dtor_nogc(&free_op1.var);
22682
22683 CHECK_EXCEPTION();
22684 ZEND_VM_NEXT_OPCODE();
22685 }
22686
ZEND_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22687 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22688 {
22689 USE_OPLINE
22690 zend_free_op free_op1;
22691
22692 SAVE_OPLINE();
22693 concat_function(&EX_T(opline->result.var).tmp_var,
22694 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22695 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22696 zval_ptr_dtor_nogc(&free_op1.var);
22697
22698 CHECK_EXCEPTION();
22699 ZEND_VM_NEXT_OPCODE();
22700 }
22701
ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22702 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22703 {
22704 USE_OPLINE
22705 zend_free_op free_op1;
22706
22707 SAVE_OPLINE();
22708 is_identical_function(&EX_T(opline->result.var).tmp_var,
22709 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22710 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22711 zval_ptr_dtor_nogc(&free_op1.var);
22712
22713 CHECK_EXCEPTION();
22714 ZEND_VM_NEXT_OPCODE();
22715 }
22716
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22717 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22718 {
22719 USE_OPLINE
22720 zend_free_op free_op1;
22721 zval *result = &EX_T(opline->result.var).tmp_var;
22722
22723 SAVE_OPLINE();
22724 is_identical_function(result,
22725 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22726 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22727 Z_LVAL_P(result) = !Z_LVAL_P(result);
22728 zval_ptr_dtor_nogc(&free_op1.var);
22729
22730 CHECK_EXCEPTION();
22731 ZEND_VM_NEXT_OPCODE();
22732 }
22733
ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22734 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22735 {
22736 USE_OPLINE
22737 zend_free_op free_op1;
22738 zval *result = &EX_T(opline->result.var).tmp_var;
22739
22740 SAVE_OPLINE();
22741 ZVAL_BOOL(result, fast_equal_function(result,
22742 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22743 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
22744 zval_ptr_dtor_nogc(&free_op1.var);
22745
22746 CHECK_EXCEPTION();
22747 ZEND_VM_NEXT_OPCODE();
22748 }
22749
ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22750 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22751 {
22752 USE_OPLINE
22753 zend_free_op free_op1;
22754 zval *result = &EX_T(opline->result.var).tmp_var;
22755
22756 SAVE_OPLINE();
22757 ZVAL_BOOL(result, fast_not_equal_function(result,
22758 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22759 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
22760 zval_ptr_dtor_nogc(&free_op1.var);
22761
22762 CHECK_EXCEPTION();
22763 ZEND_VM_NEXT_OPCODE();
22764 }
22765
ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22766 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22767 {
22768 USE_OPLINE
22769 zend_free_op free_op1;
22770 zval *result = &EX_T(opline->result.var).tmp_var;
22771
22772 SAVE_OPLINE();
22773 ZVAL_BOOL(result, fast_is_smaller_function(result,
22774 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22775 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
22776 zval_ptr_dtor_nogc(&free_op1.var);
22777
22778 CHECK_EXCEPTION();
22779 ZEND_VM_NEXT_OPCODE();
22780 }
22781
ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22782 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22783 {
22784 USE_OPLINE
22785 zend_free_op free_op1;
22786 zval *result = &EX_T(opline->result.var).tmp_var;
22787
22788 SAVE_OPLINE();
22789 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
22790 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22791 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
22792 zval_ptr_dtor_nogc(&free_op1.var);
22793
22794 CHECK_EXCEPTION();
22795 ZEND_VM_NEXT_OPCODE();
22796 }
22797
ZEND_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22798 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22799 {
22800 USE_OPLINE
22801 zend_free_op free_op1;
22802
22803 SAVE_OPLINE();
22804 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
22805 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22806 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22807 zval_ptr_dtor_nogc(&free_op1.var);
22808
22809 CHECK_EXCEPTION();
22810 ZEND_VM_NEXT_OPCODE();
22811 }
22812
ZEND_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22813 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22814 {
22815 USE_OPLINE
22816 zend_free_op free_op1;
22817
22818 SAVE_OPLINE();
22819 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
22820 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22821 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22822 zval_ptr_dtor_nogc(&free_op1.var);
22823
22824 CHECK_EXCEPTION();
22825 ZEND_VM_NEXT_OPCODE();
22826 }
22827
ZEND_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22828 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22829 {
22830 USE_OPLINE
22831 zend_free_op free_op1;
22832
22833 SAVE_OPLINE();
22834 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
22835 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22836 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22837 zval_ptr_dtor_nogc(&free_op1.var);
22838
22839 CHECK_EXCEPTION();
22840 ZEND_VM_NEXT_OPCODE();
22841 }
22842
ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22843 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22844 {
22845 USE_OPLINE
22846 zend_free_op free_op1;
22847
22848 SAVE_OPLINE();
22849 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
22850 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22851 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22852 zval_ptr_dtor_nogc(&free_op1.var);
22853
22854 CHECK_EXCEPTION();
22855 ZEND_VM_NEXT_OPCODE();
22856 }
22857
zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)22858 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
22859 {
22860 USE_OPLINE
22861 zend_free_op free_op1, free_op_data1;
22862 zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22863 zval *object;
22864 zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
22865 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
22866 int have_get_ptr = 0;
22867
22868 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
22869 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
22870 }
22871
22872 make_real_object(object_ptr TSRMLS_CC);
22873 object = *object_ptr;
22874
22875 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
22876 zend_error(E_WARNING, "Attempt to assign property of non-object");
22877
22878 FREE_OP(free_op_data1);
22879
22880 if (RETURN_VALUE_USED(opline)) {
22881 PZVAL_LOCK(&EG(uninitialized_zval));
22882 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
22883 }
22884 } else {
22885 /* here we are sure we are dealing with an object */
22886 if (0) {
22887 MAKE_REAL_ZVAL_PTR(property);
22888 }
22889
22890 /* here property is a string */
22891 if (opline->extended_value == ZEND_ASSIGN_OBJ
22892 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
22893 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
22894 if (zptr != NULL) { /* NULL means no success in getting PTR */
22895 have_get_ptr = 1;
22896 if (UNEXPECTED(*zptr == &EG(error_zval))) {
22897 if (RETURN_VALUE_USED(opline)) {
22898 PZVAL_LOCK(&EG(uninitialized_zval));
22899 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
22900 }
22901 } else {
22902 SEPARATE_ZVAL_IF_NOT_REF(zptr);
22903
22904 binary_op(*zptr, *zptr, value TSRMLS_CC);
22905 if (RETURN_VALUE_USED(opline)) {
22906 PZVAL_LOCK(*zptr);
22907 EX_T(opline->result.var).var.ptr = *zptr;
22908 }
22909 }
22910 }
22911 }
22912
22913 if (!have_get_ptr) {
22914 zval *z = NULL;
22915
22916 Z_ADDREF_P(object);
22917 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
22918 if (Z_OBJ_HT_P(object)->read_property) {
22919 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
22920 }
22921 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
22922 if (Z_OBJ_HT_P(object)->read_dimension) {
22923 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
22924 }
22925 }
22926 if (z) {
22927 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
22928 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
22929
22930 if (Z_REFCOUNT_P(z) == 0) {
22931 GC_REMOVE_ZVAL_FROM_BUFFER(z);
22932 zval_dtor(z);
22933 FREE_ZVAL(z);
22934 }
22935 z = value;
22936 }
22937 Z_ADDREF_P(z);
22938 SEPARATE_ZVAL_IF_NOT_REF(&z);
22939 binary_op(z, z, value TSRMLS_CC);
22940 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
22941 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
22942 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
22943 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
22944 }
22945 if (RETURN_VALUE_USED(opline)) {
22946 PZVAL_LOCK(z);
22947 EX_T(opline->result.var).var.ptr = z;
22948 }
22949 zval_ptr_dtor(&z);
22950 } else {
22951 zend_error(E_WARNING, "Attempt to assign property of non-object");
22952 if (RETURN_VALUE_USED(opline)) {
22953 PZVAL_LOCK(&EG(uninitialized_zval));
22954 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
22955 }
22956 }
22957 zval_ptr_dtor(&object);
22958 }
22959
22960 if (0) {
22961 zval_ptr_dtor(&property);
22962 } else {
22963
22964 }
22965 FREE_OP(free_op_data1);
22966 }
22967
22968 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
22969 /* assign_obj has two opcodes! */
22970 CHECK_EXCEPTION();
22971 ZEND_VM_INC_OPCODE();
22972 ZEND_VM_NEXT_OPCODE();
22973 }
22974
zend_binary_assign_op_helper_SPEC_VAR_CV(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)22975 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
22976 {
22977 USE_OPLINE
22978 zend_free_op free_op1, free_op_data2, free_op_data1;
22979 zval **var_ptr;
22980 zval *value;
22981
22982 SAVE_OPLINE();
22983 switch (opline->extended_value) {
22984 case ZEND_ASSIGN_OBJ:
22985 return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22986 break;
22987 case ZEND_ASSIGN_DIM: {
22988 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22989
22990 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
22991 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
22992 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
22993 if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
22994 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
22995 }
22996 return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22997 } else {
22998 zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
22999
23000 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC);
23001 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
23002 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
23003 }
23004 }
23005 break;
23006 default:
23007 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23008 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23009 /* do nothing */
23010 break;
23011 }
23012
23013 if (UNEXPECTED(var_ptr == NULL)) {
23014 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
23015 }
23016
23017 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
23018 if (RETURN_VALUE_USED(opline)) {
23019 PZVAL_LOCK(&EG(uninitialized_zval));
23020 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23021 }
23022
23023 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23024 CHECK_EXCEPTION();
23025 if (opline->extended_value == ZEND_ASSIGN_DIM) {
23026 ZEND_VM_INC_OPCODE();
23027 }
23028 ZEND_VM_NEXT_OPCODE();
23029 }
23030
23031 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
23032
23033 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
23034 && Z_OBJ_HANDLER_PP(var_ptr, get)
23035 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
23036 /* proxy object */
23037 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
23038 Z_ADDREF_P(objval);
23039 binary_op(objval, objval, value TSRMLS_CC);
23040 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
23041 zval_ptr_dtor(&objval);
23042 } else {
23043 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
23044 }
23045
23046 if (RETURN_VALUE_USED(opline)) {
23047 PZVAL_LOCK(*var_ptr);
23048 EX_T(opline->result.var).var.ptr = *var_ptr;
23049 }
23050
23051 if (opline->extended_value == ZEND_ASSIGN_DIM) {
23052 FREE_OP(free_op_data1);
23053 FREE_OP_VAR_PTR(free_op_data2);
23054 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23055 CHECK_EXCEPTION();
23056 ZEND_VM_INC_OPCODE();
23057 } else {
23058 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23059 CHECK_EXCEPTION();
23060 }
23061 ZEND_VM_NEXT_OPCODE();
23062 }
23063
ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23064 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23065 {
23066 return zend_binary_assign_op_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23067 }
23068
ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23069 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23070 {
23071 return zend_binary_assign_op_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23072 }
23073
ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23074 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23075 {
23076 return zend_binary_assign_op_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23077 }
23078
ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23079 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23080 {
23081 return zend_binary_assign_op_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23082 }
23083
ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23084 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23085 {
23086 return zend_binary_assign_op_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23087 }
23088
ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23089 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23090 {
23091 return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23092 }
23093
ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23094 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23095 {
23096 return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23097 }
23098
ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23099 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23100 {
23101 return zend_binary_assign_op_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23102 }
23103
ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23104 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23105 {
23106 return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23107 }
23108
ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23109 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23110 {
23111 return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23112 }
23113
ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23114 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23115 {
23116 return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23117 }
23118
zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)23119 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
23120 {
23121 USE_OPLINE
23122 zend_free_op free_op1;
23123 zval **object_ptr;
23124 zval *object;
23125 zval *property;
23126 zval **retval;
23127 int have_get_ptr = 0;
23128
23129 SAVE_OPLINE();
23130 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23131 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23132 retval = &EX_T(opline->result.var).var.ptr;
23133
23134 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
23135 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
23136 }
23137
23138 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
23139 object = *object_ptr;
23140
23141 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23142 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23143
23144 if (RETURN_VALUE_USED(opline)) {
23145 PZVAL_LOCK(&EG(uninitialized_zval));
23146 *retval = &EG(uninitialized_zval);
23147 }
23148 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23149 CHECK_EXCEPTION();
23150 ZEND_VM_NEXT_OPCODE();
23151 }
23152
23153 /* here we are sure we are dealing with an object */
23154
23155 if (0) {
23156 MAKE_REAL_ZVAL_PTR(property);
23157 }
23158
23159 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
23160 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23161 if (zptr != NULL) { /* NULL means no success in getting PTR */
23162 have_get_ptr = 1;
23163 if (UNEXPECTED(*zptr == &EG(error_zval))) {
23164 if (RETURN_VALUE_USED(opline)) {
23165 PZVAL_LOCK(&EG(uninitialized_zval));
23166 *retval = &EG(uninitialized_zval);
23167 }
23168 } else {
23169 SEPARATE_ZVAL_IF_NOT_REF(zptr);
23170
23171 incdec_op(*zptr);
23172 if (RETURN_VALUE_USED(opline)) {
23173 *retval = *zptr;
23174 PZVAL_LOCK(*retval);
23175 }
23176 }
23177 }
23178 }
23179
23180 if (!have_get_ptr) {
23181 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
23182 zval *z;
23183
23184 Z_ADDREF_P(object);
23185 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23186
23187 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
23188 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
23189
23190 if (Z_REFCOUNT_P(z) == 0) {
23191 GC_REMOVE_ZVAL_FROM_BUFFER(z);
23192 zval_dtor(z);
23193 FREE_ZVAL(z);
23194 }
23195 z = value;
23196 }
23197 Z_ADDREF_P(z);
23198 SEPARATE_ZVAL_IF_NOT_REF(&z);
23199 incdec_op(z);
23200 *retval = z;
23201 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23202 zval_ptr_dtor(&object);
23203 SELECTIVE_PZVAL_LOCK(*retval, opline);
23204 zval_ptr_dtor(&z);
23205 } else {
23206 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23207 if (RETURN_VALUE_USED(opline)) {
23208 PZVAL_LOCK(&EG(uninitialized_zval));
23209 *retval = &EG(uninitialized_zval);
23210 }
23211 }
23212 }
23213
23214 if (0) {
23215 zval_ptr_dtor(&property);
23216 } else {
23217
23218 }
23219 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23220 CHECK_EXCEPTION();
23221 ZEND_VM_NEXT_OPCODE();
23222 }
23223
ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23224 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23225 {
23226 return zend_pre_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23227 }
23228
ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23229 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23230 {
23231 return zend_pre_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23232 }
23233
zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)23234 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
23235 {
23236 USE_OPLINE
23237 zend_free_op free_op1;
23238 zval **object_ptr;
23239 zval *object;
23240 zval *property;
23241 zval *retval;
23242 int have_get_ptr = 0;
23243
23244 SAVE_OPLINE();
23245 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23246 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23247 retval = &EX_T(opline->result.var).tmp_var;
23248
23249 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
23250 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
23251 }
23252
23253 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
23254 object = *object_ptr;
23255
23256 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23257 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23258
23259 ZVAL_NULL(retval);
23260 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23261 CHECK_EXCEPTION();
23262 ZEND_VM_NEXT_OPCODE();
23263 }
23264
23265 /* here we are sure we are dealing with an object */
23266
23267 if (0) {
23268 MAKE_REAL_ZVAL_PTR(property);
23269 }
23270
23271 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
23272 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23273 if (zptr != NULL) { /* NULL means no success in getting PTR */
23274 have_get_ptr = 1;
23275 if (UNEXPECTED(*zptr == &EG(error_zval))) {
23276 ZVAL_NULL(retval);
23277 } else {
23278 SEPARATE_ZVAL_IF_NOT_REF(zptr);
23279
23280 ZVAL_COPY_VALUE(retval, *zptr);
23281 zendi_zval_copy_ctor(*retval);
23282
23283 incdec_op(*zptr);
23284 }
23285 }
23286 }
23287
23288 if (!have_get_ptr) {
23289 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
23290 zval *z, *z_copy;
23291
23292 Z_ADDREF_P(object);
23293 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23294 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
23295 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
23296
23297 if (Z_REFCOUNT_P(z) == 0) {
23298 GC_REMOVE_ZVAL_FROM_BUFFER(z);
23299 zval_dtor(z);
23300 FREE_ZVAL(z);
23301 }
23302 z = value;
23303 }
23304 ZVAL_COPY_VALUE(retval, z);
23305 zendi_zval_copy_ctor(*retval);
23306 ALLOC_ZVAL(z_copy);
23307 INIT_PZVAL_COPY(z_copy, z);
23308 zendi_zval_copy_ctor(*z_copy);
23309 incdec_op(z_copy);
23310 Z_ADDREF_P(z);
23311 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23312 zval_ptr_dtor(&object);
23313 zval_ptr_dtor(&z_copy);
23314 zval_ptr_dtor(&z);
23315 } else {
23316 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23317 ZVAL_NULL(retval);
23318 }
23319 }
23320
23321 if (0) {
23322 zval_ptr_dtor(&property);
23323 } else {
23324
23325 }
23326 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23327 CHECK_EXCEPTION();
23328 ZEND_VM_NEXT_OPCODE();
23329 }
23330
ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23331 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23332 {
23333 return zend_post_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23334 }
23335
ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23336 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23337 {
23338 return zend_post_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23339 }
23340
ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23341 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23342 {
23343 USE_OPLINE
23344 zend_free_op free_op1;
23345 zval *container;
23346
23347 SAVE_OPLINE();
23348 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23349 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
23350
23351 if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
23352 zval_ptr_dtor_nogc(&free_op1.var);
23353 }
23354 CHECK_EXCEPTION();
23355 ZEND_VM_NEXT_OPCODE();
23356 }
23357
ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23358 static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23359 {
23360 USE_OPLINE
23361 zend_free_op free_op1;
23362 zval **container;
23363
23364 SAVE_OPLINE();
23365 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23366
23367 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23368 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23369 }
23370 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
23371
23372 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23373 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23374 }
23375 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23376
23377 /* We are going to assign the result by reference */
23378 if (UNEXPECTED(opline->extended_value != 0)) {
23379 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
23380
23381 if (retval_ptr) {
23382 Z_DELREF_PP(retval_ptr);
23383 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
23384 Z_ADDREF_PP(retval_ptr);
23385 }
23386 }
23387
23388 CHECK_EXCEPTION();
23389 ZEND_VM_NEXT_OPCODE();
23390 }
23391
ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23392 static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23393 {
23394 USE_OPLINE
23395 zend_free_op free_op1;
23396 zval **container;
23397
23398 SAVE_OPLINE();
23399 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23400
23401 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23402 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23403 }
23404 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC);
23405
23406 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23407 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23408 }
23409 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23410 CHECK_EXCEPTION();
23411 ZEND_VM_NEXT_OPCODE();
23412 }
23413
ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23414 static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23415 {
23416 USE_OPLINE
23417 zend_free_op free_op1;
23418 zval *container;
23419
23420 SAVE_OPLINE();
23421 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23422 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC);
23423
23424 zval_ptr_dtor_nogc(&free_op1.var);
23425 CHECK_EXCEPTION();
23426 ZEND_VM_NEXT_OPCODE();
23427 }
23428
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23429 static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23430 {
23431 USE_OPLINE
23432 zend_free_op free_op1;
23433
23434 SAVE_OPLINE();
23435
23436 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
23437 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23438 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23439 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23440 }
23441 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
23442 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23443 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23444 }
23445
23446 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23447 } else {
23448 zval *container;
23449
23450 if (IS_CV == IS_UNUSED) {
23451 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
23452 }
23453 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23454 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
23455
23456 zval_ptr_dtor_nogc(&free_op1.var);
23457 }
23458 CHECK_EXCEPTION();
23459 ZEND_VM_NEXT_OPCODE();
23460 }
23461
ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23462 static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23463 {
23464 USE_OPLINE
23465 zend_free_op free_op1;
23466 zval **container;
23467
23468 SAVE_OPLINE();
23469 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23470
23471 if (IS_VAR == IS_CV) {
23472 if (container != &EG(uninitialized_zval_ptr)) {
23473 SEPARATE_ZVAL_IF_NOT_REF(container);
23474 }
23475 }
23476 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23477 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23478 }
23479 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_UNSET TSRMLS_CC);
23480
23481 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23482 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23483 }
23484 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23485 if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
23486 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
23487 ZEND_VM_NEXT_OPCODE();
23488 } else {
23489 zend_free_op free_res;
23490 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
23491
23492 PZVAL_UNLOCK(*retval_ptr, &free_res);
23493 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
23494 SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
23495 }
23496 PZVAL_LOCK(*retval_ptr);
23497 FREE_OP_VAR_PTR(free_res);
23498 CHECK_EXCEPTION();
23499 ZEND_VM_NEXT_OPCODE();
23500 }
23501 }
23502
zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS)23503 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS)
23504 {
23505 USE_OPLINE
23506 zend_free_op free_op1;
23507 zval *container;
23508
23509 zval *offset;
23510
23511 SAVE_OPLINE();
23512 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23513 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23514
23515 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
23516 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
23517 zend_error(E_NOTICE, "Trying to get property of non-object");
23518 PZVAL_LOCK(&EG(uninitialized_zval));
23519 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23520
23521 } else {
23522 zval *retval;
23523
23524 if (0) {
23525 MAKE_REAL_ZVAL_PTR(offset);
23526 }
23527
23528 /* here we are sure we are dealing with an object */
23529 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23530
23531 PZVAL_LOCK(retval);
23532 EX_T(opline->result.var).var.ptr = retval;
23533
23534 if (0) {
23535 zval_ptr_dtor(&offset);
23536 } else {
23537
23538 }
23539 }
23540
23541 zval_ptr_dtor_nogc(&free_op1.var);
23542 CHECK_EXCEPTION();
23543 ZEND_VM_NEXT_OPCODE();
23544 }
23545
ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23546 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23547 {
23548 return zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23549 }
23550
ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23551 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23552 {
23553 USE_OPLINE
23554 zend_free_op free_op1;
23555 zval *property;
23556 zval **container;
23557
23558 SAVE_OPLINE();
23559 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23560
23561 if (0) {
23562 MAKE_REAL_ZVAL_PTR(property);
23563 }
23564 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23565 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23566 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23567 }
23568
23569 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
23570 if (0) {
23571 zval_ptr_dtor(&property);
23572 } else {
23573
23574 }
23575 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23576 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23577 }
23578 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23579
23580 /* We are going to assign the result by reference */
23581 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
23582 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
23583
23584 Z_DELREF_PP(retval_ptr);
23585 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
23586 Z_ADDREF_PP(retval_ptr);
23587 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
23588 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
23589 }
23590
23591 CHECK_EXCEPTION();
23592 ZEND_VM_NEXT_OPCODE();
23593 }
23594
ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23595 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23596 {
23597 USE_OPLINE
23598 zend_free_op free_op1;
23599 zval *property;
23600 zval **container;
23601
23602 SAVE_OPLINE();
23603 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23604 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23605
23606 if (0) {
23607 MAKE_REAL_ZVAL_PTR(property);
23608 }
23609 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23610 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23611 }
23612 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
23613 if (0) {
23614 zval_ptr_dtor(&property);
23615 } else {
23616
23617 }
23618 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23619 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23620 }
23621 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23622 CHECK_EXCEPTION();
23623 ZEND_VM_NEXT_OPCODE();
23624 }
23625
ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23626 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23627 {
23628 USE_OPLINE
23629 zend_free_op free_op1;
23630 zval *container;
23631
23632 zval *offset;
23633
23634 SAVE_OPLINE();
23635 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23636 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23637
23638 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
23639 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
23640 PZVAL_LOCK(&EG(uninitialized_zval));
23641 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23642
23643 } else {
23644 zval *retval;
23645
23646 if (0) {
23647 MAKE_REAL_ZVAL_PTR(offset);
23648 }
23649
23650 /* here we are sure we are dealing with an object */
23651 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23652
23653 PZVAL_LOCK(retval);
23654 EX_T(opline->result.var).var.ptr = retval;
23655
23656 if (0) {
23657 zval_ptr_dtor(&offset);
23658 } else {
23659
23660 }
23661 }
23662
23663 zval_ptr_dtor_nogc(&free_op1.var);
23664 CHECK_EXCEPTION();
23665 ZEND_VM_NEXT_OPCODE();
23666 }
23667
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23668 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23669 {
23670 USE_OPLINE
23671
23672 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
23673 /* Behave like FETCH_OBJ_W */
23674 zend_free_op free_op1;
23675 zval *property;
23676 zval **container;
23677
23678 SAVE_OPLINE();
23679 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23680 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23681
23682 if (0) {
23683 MAKE_REAL_ZVAL_PTR(property);
23684 }
23685 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23686 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23687 }
23688 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
23689 if (0) {
23690 zval_ptr_dtor(&property);
23691 } else {
23692
23693 }
23694 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23695 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23696 }
23697 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23698 CHECK_EXCEPTION();
23699 ZEND_VM_NEXT_OPCODE();
23700 } else {
23701 return zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23702 }
23703 }
23704
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23705 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23706 {
23707 USE_OPLINE
23708 zend_free_op free_op1, free_res;
23709 zval **container;
23710 zval *property;
23711
23712 SAVE_OPLINE();
23713 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23714 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23715
23716 if (IS_VAR == IS_CV) {
23717 if (container != &EG(uninitialized_zval_ptr)) {
23718 SEPARATE_ZVAL_IF_NOT_REF(container);
23719 }
23720 }
23721 if (0) {
23722 MAKE_REAL_ZVAL_PTR(property);
23723 }
23724 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23725 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23726 }
23727 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
23728 if (0) {
23729 zval_ptr_dtor(&property);
23730 } else {
23731
23732 }
23733 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23734 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23735 }
23736 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23737
23738 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
23739 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
23740 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
23741 }
23742 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
23743 FREE_OP_VAR_PTR(free_res);
23744 CHECK_EXCEPTION();
23745 ZEND_VM_NEXT_OPCODE();
23746 }
23747
ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23748 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23749 {
23750 USE_OPLINE
23751 zend_free_op free_op1;
23752 zval **object_ptr;
23753 zval *property_name;
23754
23755 SAVE_OPLINE();
23756 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23757 property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23758
23759 if (0) {
23760 MAKE_REAL_ZVAL_PTR(property_name);
23761 }
23762 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
23763 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23764 }
23765 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23766 if (0) {
23767 zval_ptr_dtor(&property_name);
23768 } else {
23769
23770 }
23771 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23772 /* assign_obj has two opcodes! */
23773 CHECK_EXCEPTION();
23774 ZEND_VM_INC_OPCODE();
23775 ZEND_VM_NEXT_OPCODE();
23776 }
23777
ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23778 static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23779 {
23780 USE_OPLINE
23781 zend_free_op free_op1;
23782 zval **object_ptr;
23783
23784 SAVE_OPLINE();
23785 object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23786
23787 if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
23788 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23789 }
23790 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
23791
23792 zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23793
23794 if (0) {
23795 MAKE_REAL_ZVAL_PTR(property_name);
23796 }
23797 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23798 if (0) {
23799 zval_ptr_dtor(&property_name);
23800 } else {
23801
23802 }
23803 } else {
23804 zend_free_op free_op_data1, free_op_data2;
23805 zval *value;
23806 zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23807 zval **variable_ptr_ptr;
23808
23809 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W TSRMLS_CC);
23810
23811 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
23812 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
23813 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
23814 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
23815 if (RETURN_VALUE_USED(opline)) {
23816 zval *retval;
23817
23818 ALLOC_ZVAL(retval);
23819 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
23820 INIT_PZVAL(retval);
23821 EX_T(opline->result.var).var.ptr = retval;
23822 }
23823 } else if (RETURN_VALUE_USED(opline)) {
23824 PZVAL_LOCK(&EG(uninitialized_zval));
23825 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23826 }
23827 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
23828 if (IS_TMP_FREE(free_op_data1)) {
23829 zval_dtor(value);
23830 }
23831 if (RETURN_VALUE_USED(opline)) {
23832 PZVAL_LOCK(&EG(uninitialized_zval));
23833 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23834 }
23835 } else {
23836 if ((opline+1)->op1_type == IS_TMP_VAR) {
23837 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23838 } else if ((opline+1)->op1_type == IS_CONST) {
23839 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23840 } else {
23841 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23842 }
23843 if (RETURN_VALUE_USED(opline)) {
23844 PZVAL_LOCK(value);
23845 EX_T(opline->result.var).var.ptr = value;
23846 }
23847 }
23848 FREE_OP_VAR_PTR(free_op_data2);
23849 FREE_OP_IF_VAR(free_op_data1);
23850 }
23851 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23852 /* assign_dim has two opcodes! */
23853 CHECK_EXCEPTION();
23854 ZEND_VM_INC_OPCODE();
23855 ZEND_VM_NEXT_OPCODE();
23856 }
23857
ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23858 static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23859 {
23860 USE_OPLINE
23861 zend_free_op free_op1;
23862 zval *value;
23863 zval **variable_ptr_ptr;
23864
23865 SAVE_OPLINE();
23866 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23867 variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23868
23869 if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
23870 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) {
23871 if (RETURN_VALUE_USED(opline)) {
23872 zval *retval;
23873
23874 ALLOC_ZVAL(retval);
23875 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
23876 INIT_PZVAL(retval);
23877 EX_T(opline->result.var).var.ptr = retval;
23878 }
23879 } else if (RETURN_VALUE_USED(opline)) {
23880 PZVAL_LOCK(&EG(uninitialized_zval));
23881 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23882 }
23883 } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
23884 if (0) {
23885 zval_dtor(value);
23886 }
23887 if (RETURN_VALUE_USED(opline)) {
23888 PZVAL_LOCK(&EG(uninitialized_zval));
23889 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23890 }
23891 } else {
23892 if (IS_CV == IS_TMP_VAR) {
23893 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23894 } else if (IS_CV == IS_CONST) {
23895 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23896 } else {
23897 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23898 }
23899 if (RETURN_VALUE_USED(opline)) {
23900 PZVAL_LOCK(value);
23901 EX_T(opline->result.var).var.ptr = value;
23902 }
23903 }
23904
23905 if (IS_VAR == IS_VAR && (free_op1.var != NULL)) {
23906 zval_ptr_dtor_nogc(&value);
23907 }
23908
23909 /* zend_assign_to_variable() always takes care of op2, never free it! */
23910
23911 CHECK_EXCEPTION();
23912 ZEND_VM_NEXT_OPCODE();
23913 }
23914
ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23915 static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23916 {
23917 USE_OPLINE
23918 zend_free_op free_op1, free_op2;
23919 zval **variable_ptr_ptr;
23920 zval **value_ptr_ptr;
23921
23922 SAVE_OPLINE();
23923 value_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC);
23924
23925 if (IS_VAR == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
23926 zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
23927 }
23928
23929 if (IS_CV == IS_VAR &&
23930 value_ptr_ptr &&
23931 !Z_ISREF_PP(value_ptr_ptr) &&
23932 opline->extended_value == ZEND_RETURNS_FUNCTION &&
23933 !EX_T(opline->op2.var).var.fcall_returned_reference) {
23934 if (free_op2.var == NULL) {
23935 PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
23936 }
23937 zend_error(E_STRICT, "Only variables should be assigned by reference");
23938 if (UNEXPECTED(EG(exception) != NULL)) {
23939
23940 HANDLE_EXCEPTION();
23941 }
23942 return ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23943 } else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
23944 PZVAL_LOCK(*value_ptr_ptr);
23945 }
23946
23947 variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23948 if ((IS_CV == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
23949 (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
23950 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
23951 } else if ((IS_CV == IS_VAR && UNEXPECTED(*value_ptr_ptr == &EG(error_zval))) ||
23952 (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval)))) {
23953 variable_ptr_ptr = &EG(uninitialized_zval_ptr);
23954 } else {
23955 zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
23956 if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
23957 Z_DELREF_PP(variable_ptr_ptr);
23958 }
23959 }
23960
23961 if (RETURN_VALUE_USED(opline)) {
23962 PZVAL_LOCK(*variable_ptr_ptr);
23963 EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
23964 }
23965
23966 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23967
23968 CHECK_EXCEPTION();
23969 ZEND_VM_NEXT_OPCODE();
23970 }
23971
ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23972 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23973 {
23974 USE_OPLINE
23975 zval *function_name;
23976 char *function_name_strval;
23977 int function_name_strlen;
23978 zend_free_op free_op1;
23979 call_slot *call = EX(call_slots) + opline->result.num;
23980
23981 SAVE_OPLINE();
23982
23983 function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23984
23985 if (IS_CV != IS_CONST &&
23986 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
23987 if (UNEXPECTED(EG(exception) != NULL)) {
23988 HANDLE_EXCEPTION();
23989 }
23990 zend_error_noreturn(E_ERROR, "Method name must be a string");
23991 }
23992
23993 function_name_strval = Z_STRVAL_P(function_name);
23994 function_name_strlen = Z_STRLEN_P(function_name);
23995
23996 call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23997
23998 if (EXPECTED(call->object != NULL) &&
23999 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
24000 call->called_scope = Z_OBJCE_P(call->object);
24001
24002 if (IS_CV != IS_CONST ||
24003 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
24004 zval *object = call->object;
24005
24006 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
24007 zend_error_noreturn(E_ERROR, "Object does not support method calls");
24008 }
24009
24010 /* First, locate the function. */
24011 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
24012 if (UNEXPECTED(call->fbc == NULL)) {
24013 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
24014 }
24015 if (IS_CV == IS_CONST &&
24016 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
24017 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
24018 EXPECTED(call->object == object)) {
24019 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
24020 }
24021 }
24022 } else {
24023 if (UNEXPECTED(EG(exception) != NULL)) {
24024
24025 HANDLE_EXCEPTION();
24026 }
24027 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
24028 }
24029
24030 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
24031 call->object = NULL;
24032 } else {
24033 if (!PZVAL_IS_REF(call->object)) {
24034 Z_ADDREF_P(call->object); /* For $this pointer */
24035 } else {
24036 zval *this_ptr;
24037 ALLOC_ZVAL(this_ptr);
24038 INIT_PZVAL_COPY(this_ptr, call->object);
24039 zval_copy_ctor(this_ptr);
24040 call->object = this_ptr;
24041 }
24042 }
24043
24044 call->num_additional_args = 0;
24045 call->is_ctor_call = 0;
24046 EX(call) = call;
24047
24048 zval_ptr_dtor_nogc(&free_op1.var);
24049
24050 CHECK_EXCEPTION();
24051 ZEND_VM_NEXT_OPCODE();
24052 }
24053
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24054 static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24055 {
24056 USE_OPLINE
24057 zval *function_name;
24058 zend_class_entry *ce;
24059 call_slot *call = EX(call_slots) + opline->result.num;
24060
24061 SAVE_OPLINE();
24062
24063 if (IS_VAR == IS_CONST) {
24064 /* no function found. try a static method in class */
24065 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
24066 ce = CACHED_PTR(opline->op1.literal->cache_slot);
24067 } else {
24068 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
24069 if (UNEXPECTED(EG(exception) != NULL)) {
24070 HANDLE_EXCEPTION();
24071 }
24072 if (UNEXPECTED(ce == NULL)) {
24073 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
24074 }
24075 CACHE_PTR(opline->op1.literal->cache_slot, ce);
24076 }
24077 call->called_scope = ce;
24078 } else {
24079 ce = EX_T(opline->op1.var).class_entry;
24080
24081 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
24082 call->called_scope = EG(called_scope);
24083 } else {
24084 call->called_scope = ce;
24085 }
24086 }
24087
24088 if (IS_VAR == IS_CONST &&
24089 IS_CV == IS_CONST &&
24090 CACHED_PTR(opline->op2.literal->cache_slot)) {
24091 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
24092 } else if (IS_VAR != IS_CONST &&
24093 IS_CV == IS_CONST &&
24094 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
24095 /* do nothing */
24096 } else if (IS_CV != IS_UNUSED) {
24097 char *function_name_strval = NULL;
24098 int function_name_strlen = 0;
24099
24100
24101 if (IS_CV == IS_CONST) {
24102 function_name_strval = Z_STRVAL_P(opline->op2.zv);
24103 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
24104 } else {
24105 function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24106
24107 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
24108 if (UNEXPECTED(EG(exception) != NULL)) {
24109 HANDLE_EXCEPTION();
24110 }
24111 zend_error_noreturn(E_ERROR, "Function name must be a string");
24112 } else {
24113 function_name_strval = Z_STRVAL_P(function_name);
24114 function_name_strlen = Z_STRLEN_P(function_name);
24115 }
24116 }
24117
24118 if (function_name_strval) {
24119 if (ce->get_static_method) {
24120 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
24121 } else {
24122 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
24123 }
24124 if (UNEXPECTED(call->fbc == NULL)) {
24125 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
24126 }
24127 if (IS_CV == IS_CONST &&
24128 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
24129 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
24130 if (IS_VAR == IS_CONST) {
24131 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
24132 } else {
24133 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
24134 }
24135 }
24136 }
24137 if (IS_CV != IS_CONST) {
24138
24139 }
24140 } else {
24141 if (UNEXPECTED(ce->constructor == NULL)) {
24142 zend_error_noreturn(E_ERROR, "Cannot call constructor");
24143 }
24144 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
24145 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
24146 }
24147 call->fbc = ce->constructor;
24148 }
24149
24150 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
24151 call->object = NULL;
24152 } else {
24153 if (EG(This) &&
24154 Z_OBJ_HT_P(EG(This))->get_class_entry &&
24155 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
24156 /* We are calling method of the other (incompatible) class,
24157 but passing $this. This is done for compatibility with php-4. */
24158 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
24159 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
24160 } else {
24161 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
24162 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
24163 }
24164 }
24165 if ((call->object = EG(This))) {
24166 Z_ADDREF_P(call->object);
24167 call->called_scope = Z_OBJCE_P(call->object);
24168 }
24169 }
24170
24171 call->num_additional_args = 0;
24172 call->is_ctor_call = 0;
24173 EX(call) = call;
24174
24175 CHECK_EXCEPTION();
24176 ZEND_VM_NEXT_OPCODE();
24177 }
24178
ZEND_CASE_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24179 static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24180 {
24181 USE_OPLINE
24182 zend_free_op free_op1;
24183
24184 SAVE_OPLINE();
24185 is_equal_function(&EX_T(opline->result.var).tmp_var,
24186 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
24187 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
24188
24189 CHECK_EXCEPTION();
24190 ZEND_VM_NEXT_OPCODE();
24191 }
24192
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24193 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24194 {
24195 USE_OPLINE
24196 zend_free_op free_op1;
24197 zval *expr_ptr;
24198
24199 SAVE_OPLINE();
24200 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
24201 zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24202
24203 if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
24204 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
24205 }
24206 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
24207 expr_ptr = *expr_ptr_ptr;
24208 Z_ADDREF_P(expr_ptr);
24209 } else {
24210 expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24211 if (0) { /* temporary variable */
24212 zval *new_expr;
24213
24214 ALLOC_ZVAL(new_expr);
24215 INIT_PZVAL_COPY(new_expr, expr_ptr);
24216 expr_ptr = new_expr;
24217 } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
24218 zval *new_expr;
24219
24220 ALLOC_ZVAL(new_expr);
24221 INIT_PZVAL_COPY(new_expr, expr_ptr);
24222 expr_ptr = new_expr;
24223 zendi_zval_copy_ctor(*expr_ptr);
24224 zval_ptr_dtor_nogc(&free_op1.var);
24225 } else if (IS_VAR == IS_CV) {
24226 Z_ADDREF_P(expr_ptr);
24227 }
24228 }
24229
24230 if (IS_CV != IS_UNUSED) {
24231
24232 zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24233 ulong hval;
24234
24235 switch (Z_TYPE_P(offset)) {
24236 case IS_DOUBLE:
24237 hval = zend_dval_to_lval(Z_DVAL_P(offset));
24238 goto num_index;
24239 case IS_LONG:
24240 case IS_BOOL:
24241 hval = Z_LVAL_P(offset);
24242 num_index:
24243 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
24244 break;
24245 case IS_STRING:
24246 if (IS_CV == IS_CONST) {
24247 hval = Z_HASH_P(offset);
24248 } else {
24249 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
24250 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
24251 }
24252 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
24253 break;
24254 case IS_NULL:
24255 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
24256 break;
24257 default:
24258 zend_error(E_WARNING, "Illegal offset type");
24259 zval_ptr_dtor(&expr_ptr);
24260 /* do nothing */
24261 break;
24262 }
24263
24264 } else {
24265 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
24266 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
24267 zval_ptr_dtor(&expr_ptr);
24268 }
24269 }
24270 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
24271 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
24272 }
24273 CHECK_EXCEPTION();
24274 ZEND_VM_NEXT_OPCODE();
24275 }
24276
ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24277 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24278 {
24279 USE_OPLINE
24280
24281 array_init(&EX_T(opline->result.var).tmp_var);
24282 if (IS_VAR == IS_UNUSED) {
24283 ZEND_VM_NEXT_OPCODE();
24284 #if 0 || IS_VAR != IS_UNUSED
24285 } else {
24286 return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24287 #endif
24288 }
24289 }
24290
ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24291 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24292 {
24293 USE_OPLINE
24294 zend_free_op free_op1;
24295 zval **container;
24296 zval *offset;
24297 ulong hval;
24298
24299 SAVE_OPLINE();
24300 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24301 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
24302 SEPARATE_ZVAL_IF_NOT_REF(container);
24303 }
24304 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24305
24306 if (IS_VAR != IS_VAR || container) {
24307 switch (Z_TYPE_PP(container)) {
24308 case IS_ARRAY: {
24309 HashTable *ht = Z_ARRVAL_PP(container);
24310
24311 switch (Z_TYPE_P(offset)) {
24312 case IS_DOUBLE:
24313 hval = zend_dval_to_lval(Z_DVAL_P(offset));
24314 zend_hash_index_del(ht, hval);
24315 break;
24316 case IS_RESOURCE:
24317 case IS_BOOL:
24318 case IS_LONG:
24319 hval = Z_LVAL_P(offset);
24320 zend_hash_index_del(ht, hval);
24321 break;
24322 case IS_STRING:
24323 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24324 Z_ADDREF_P(offset);
24325 }
24326 if (IS_CV == IS_CONST) {
24327 hval = Z_HASH_P(offset);
24328 } else {
24329 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
24330 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
24331 }
24332 if (ht == &EG(symbol_table)) {
24333 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
24334 } else {
24335 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
24336 }
24337 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24338 zval_ptr_dtor(&offset);
24339 }
24340 break;
24341 num_index_dim:
24342 zend_hash_index_del(ht, hval);
24343 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24344 zval_ptr_dtor(&offset);
24345 }
24346 break;
24347 case IS_NULL:
24348 zend_hash_del(ht, "", sizeof(""));
24349 break;
24350 default:
24351 zend_error(E_WARNING, "Illegal offset type in unset");
24352 break;
24353 }
24354
24355 break;
24356 }
24357 case IS_OBJECT:
24358 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
24359 zend_error_noreturn(E_ERROR, "Cannot use object as array");
24360 }
24361 if (0) {
24362 MAKE_REAL_ZVAL_PTR(offset);
24363 }
24364 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
24365 if (0) {
24366 zval_ptr_dtor(&offset);
24367 } else {
24368
24369 }
24370 break;
24371 case IS_STRING:
24372 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
24373 ZEND_VM_CONTINUE(); /* bailed out before */
24374 default:
24375
24376 break;
24377 }
24378 } else {
24379
24380 }
24381 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
24382
24383 CHECK_EXCEPTION();
24384 ZEND_VM_NEXT_OPCODE();
24385 }
24386
ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24387 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24388 {
24389 USE_OPLINE
24390 zend_free_op free_op1;
24391 zval **container;
24392 zval *offset;
24393
24394 SAVE_OPLINE();
24395 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24396 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24397
24398 if (IS_VAR != IS_VAR || container) {
24399 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
24400 SEPARATE_ZVAL_IF_NOT_REF(container);
24401 }
24402 if (Z_TYPE_PP(container) == IS_OBJECT) {
24403 if (0) {
24404 MAKE_REAL_ZVAL_PTR(offset);
24405 }
24406 if (Z_OBJ_HT_P(*container)->unset_property) {
24407 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
24408 } else {
24409 zend_error(E_NOTICE, "Trying to unset property of non-object");
24410 }
24411 if (0) {
24412 zval_ptr_dtor(&offset);
24413 } else {
24414
24415 }
24416 } else {
24417
24418 }
24419 } else {
24420
24421 }
24422 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
24423
24424 CHECK_EXCEPTION();
24425 ZEND_VM_NEXT_OPCODE();
24426 }
24427
zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)24428 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
24429 {
24430 USE_OPLINE
24431 zend_free_op free_op1;
24432 zval *container;
24433 zval **value = NULL;
24434 int result = 0;
24435 ulong hval;
24436 zval *offset;
24437
24438 SAVE_OPLINE();
24439 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24440 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24441
24442 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
24443 HashTable *ht;
24444 int isset = 0;
24445
24446 ht = Z_ARRVAL_P(container);
24447
24448 switch (Z_TYPE_P(offset)) {
24449 case IS_DOUBLE:
24450 hval = zend_dval_to_lval(Z_DVAL_P(offset));
24451 goto num_index_prop;
24452 case IS_RESOURCE:
24453 case IS_BOOL:
24454 case IS_LONG:
24455 hval = Z_LVAL_P(offset);
24456 num_index_prop:
24457 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
24458 isset = 1;
24459 }
24460 break;
24461 case IS_STRING:
24462 if (IS_CV == IS_CONST) {
24463 hval = Z_HASH_P(offset);
24464 } else {
24465 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
24466 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
24467 }
24468 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
24469 isset = 1;
24470 }
24471 break;
24472 case IS_NULL:
24473 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
24474 isset = 1;
24475 }
24476 break;
24477 default:
24478 zend_error(E_WARNING, "Illegal offset type in isset or empty");
24479 break;
24480 }
24481
24482 if (opline->extended_value & ZEND_ISSET) {
24483 if (isset && Z_TYPE_PP(value) == IS_NULL) {
24484 result = 0;
24485 } else {
24486 result = isset;
24487 }
24488 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
24489 if (!isset || !i_zend_is_true(*value)) {
24490 result = 0;
24491 } else {
24492 result = 1;
24493 }
24494 }
24495
24496 } else if (Z_TYPE_P(container) == IS_OBJECT) {
24497 if (0) {
24498 MAKE_REAL_ZVAL_PTR(offset);
24499 }
24500 if (prop_dim) {
24501 if (Z_OBJ_HT_P(container)->has_property) {
24502 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
24503 } else {
24504 zend_error(E_NOTICE, "Trying to check property of non-object");
24505 result = 0;
24506 }
24507 } else {
24508 if (Z_OBJ_HT_P(container)->has_dimension) {
24509 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
24510 } else {
24511 zend_error(E_NOTICE, "Trying to check element of non-array");
24512 result = 0;
24513 }
24514 }
24515 if (0) {
24516 zval_ptr_dtor(&offset);
24517 } else {
24518
24519 }
24520 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
24521 zval tmp;
24522
24523 if (Z_TYPE_P(offset) != IS_LONG) {
24524 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
24525 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
24526 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
24527 ZVAL_COPY_VALUE(&tmp, offset);
24528 zval_copy_ctor(&tmp);
24529 convert_to_long(&tmp);
24530 offset = &tmp;
24531 } else {
24532 /* can not be converted to proper offset, return "not set" */
24533 result = 0;
24534 }
24535 }
24536 if (Z_TYPE_P(offset) == IS_LONG) {
24537 if (opline->extended_value & ZEND_ISSET) {
24538 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
24539 result = 1;
24540 }
24541 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
24542 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
24543 result = 1;
24544 }
24545 }
24546 }
24547
24548 } else {
24549
24550 }
24551
24552 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
24553 if (opline->extended_value & ZEND_ISSET) {
24554 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
24555 } else {
24556 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
24557 }
24558
24559 zval_ptr_dtor_nogc(&free_op1.var);
24560
24561 CHECK_EXCEPTION();
24562 ZEND_VM_NEXT_OPCODE();
24563 }
24564
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24565 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24566 {
24567 return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24568 }
24569
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24570 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24571 {
24572 return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24573 }
24574
ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24575 static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24576 {
24577 USE_OPLINE
24578
24579 /* The generator object is stored in return_value_ptr_ptr */
24580 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
24581
24582 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
24583 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
24584 }
24585
24586 /* Destroy the previously yielded value */
24587 if (generator->value) {
24588 zval_ptr_dtor(&generator->value);
24589 }
24590
24591 /* Destroy the previously yielded key */
24592 if (generator->key) {
24593 zval_ptr_dtor(&generator->key);
24594 }
24595
24596 /* Set the new yielded value */
24597 if (IS_VAR != IS_UNUSED) {
24598 zend_free_op free_op1;
24599
24600 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
24601 /* Constants and temporary variables aren't yieldable by reference,
24602 * but we still allow them with a notice. */
24603 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
24604 zval *value, *copy;
24605
24606 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
24607
24608 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24609 ALLOC_ZVAL(copy);
24610 INIT_PZVAL_COPY(copy, value);
24611
24612 /* Temporary variables don't need ctor copying */
24613 if (!0) {
24614 zval_copy_ctor(copy);
24615 }
24616
24617 generator->value = copy;
24618 } else {
24619 zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24620
24621 if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
24622 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
24623 }
24624
24625 /* If a function call result is yielded and the function did
24626 * not return by reference we throw a notice. */
24627 if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
24628 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
24629 && EX_T(opline->op1.var).var.fcall_returned_reference)
24630 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
24631 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
24632
24633 Z_ADDREF_PP(value_ptr);
24634 generator->value = *value_ptr;
24635 } else {
24636 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
24637 Z_ADDREF_PP(value_ptr);
24638 generator->value = *value_ptr;
24639 }
24640
24641 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
24642 }
24643 } else {
24644 zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24645
24646 /* Consts, temporary variables and references need copying */
24647 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
24648 || PZVAL_IS_REF(value)
24649 ) {
24650 zval *copy;
24651
24652 ALLOC_ZVAL(copy);
24653 INIT_PZVAL_COPY(copy, value);
24654
24655 /* Temporary variables don't need ctor copying */
24656 if (!0) {
24657 zval_copy_ctor(copy);
24658 }
24659
24660 generator->value = copy;
24661 zval_ptr_dtor_nogc(&free_op1.var);
24662 } else {
24663 if (IS_VAR == IS_CV) {
24664 Z_ADDREF_P(value);
24665 }
24666 generator->value = value;
24667 }
24668 }
24669 } else {
24670 /* If no value was specified yield null */
24671 Z_ADDREF(EG(uninitialized_zval));
24672 generator->value = &EG(uninitialized_zval);
24673 }
24674
24675 /* Set the new yielded key */
24676 if (IS_CV != IS_UNUSED) {
24677
24678 zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24679
24680 /* Consts, temporary variables and references need copying */
24681 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
24682 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
24683 ) {
24684 zval *copy;
24685
24686 ALLOC_ZVAL(copy);
24687 INIT_PZVAL_COPY(copy, key);
24688
24689 /* Temporary variables don't need ctor copying */
24690 if (!0) {
24691 zval_copy_ctor(copy);
24692 }
24693
24694 generator->key = copy;
24695 } else {
24696 Z_ADDREF_P(key);
24697 generator->key = key;
24698 }
24699
24700 if (Z_TYPE_P(generator->key) == IS_LONG
24701 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
24702 ) {
24703 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
24704 }
24705
24706 } else {
24707 /* If no key was specified we use auto-increment keys */
24708 generator->largest_used_integer_key++;
24709
24710 ALLOC_INIT_ZVAL(generator->key);
24711 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
24712 }
24713
24714 if (RETURN_VALUE_USED(opline)) {
24715 /* If the return value of yield is used set the send
24716 * target and initialize it to NULL */
24717 generator->send_target = &EX_T(opline->result.var).var.ptr;
24718 Z_ADDREF(EG(uninitialized_zval));
24719 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
24720 } else {
24721 generator->send_target = NULL;
24722 }
24723
24724 /* We increment to the next op, so we are at the correct position when the
24725 * generator is resumed. */
24726 ZEND_VM_INC_OPCODE();
24727
24728 /* The GOTO VM uses a local opline variable. We need to set the opline
24729 * variable in execute_data so we don't resume at an old position. */
24730 SAVE_OPLINE();
24731
24732 ZEND_VM_RETURN();
24733 }
24734
ZEND_POW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24735 static int ZEND_FASTCALL ZEND_POW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24736 {
24737 USE_OPLINE
24738 zend_free_op free_op1;
24739
24740 SAVE_OPLINE();
24741 pow_function(&EX_T(opline->result.var).tmp_var,
24742 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
24743 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
24744 zval_ptr_dtor_nogc(&free_op1.var);
24745
24746 CHECK_EXCEPTION();
24747 ZEND_VM_NEXT_OPCODE();
24748 }
24749
ZEND_ASSIGN_POW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24750 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24751 {
24752 return zend_binary_assign_op_helper_SPEC_VAR_CV(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24753 }
24754
ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24755 static int ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24756 {
24757 USE_OPLINE
24758
24759 zval *obj;
24760 zend_class_entry *ce;
24761 zend_function *clone;
24762 zend_object_clone_obj_t clone_call;
24763
24764 SAVE_OPLINE();
24765 obj = _get_obj_zval_ptr_unused(TSRMLS_C);
24766
24767 if (IS_UNUSED == IS_CONST ||
24768 UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
24769 if (UNEXPECTED(EG(exception) != NULL)) {
24770 HANDLE_EXCEPTION();
24771 }
24772 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
24773 }
24774
24775 ce = Z_OBJCE_P(obj);
24776 clone = ce ? ce->clone : NULL;
24777 clone_call = Z_OBJ_HT_P(obj)->clone_obj;
24778 if (UNEXPECTED(clone_call == NULL)) {
24779 if (ce) {
24780 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
24781 } else {
24782 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
24783 }
24784 }
24785
24786 if (ce && clone) {
24787 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
24788 /* Ensure that if we're calling a private function, we're allowed to do so.
24789 */
24790 if (UNEXPECTED(ce != EG(scope))) {
24791 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
24792 }
24793 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
24794 /* Ensure that if we're calling a protected function, we're allowed to do so.
24795 */
24796 if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
24797 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
24798 }
24799 }
24800 }
24801
24802 if (EXPECTED(EG(exception) == NULL)) {
24803 zval *retval;
24804
24805 ALLOC_ZVAL(retval);
24806 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
24807 Z_TYPE_P(retval) = IS_OBJECT;
24808 Z_SET_REFCOUNT_P(retval, 1);
24809 Z_SET_ISREF_P(retval);
24810 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
24811 zval_ptr_dtor(&retval);
24812 } else {
24813 EX_T(opline->result.var).var.ptr = retval;
24814 }
24815 }
24816
24817 CHECK_EXCEPTION();
24818 ZEND_VM_NEXT_OPCODE();
24819 }
24820
ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24821 static int ZEND_FASTCALL ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24822 {
24823 #if 0 || (IS_UNUSED != IS_UNUSED)
24824 USE_OPLINE
24825
24826 SAVE_OPLINE();
24827 if (IS_UNUSED != IS_UNUSED) {
24828
24829 zval *ptr = NULL;
24830
24831 if (Z_TYPE_P(ptr) == IS_LONG) {
24832 EG(exit_status) = Z_LVAL_P(ptr);
24833 } else {
24834 zend_print_variable(ptr);
24835 }
24836
24837 }
24838 #endif
24839 zend_bailout();
24840 ZEND_VM_NEXT_OPCODE(); /* Never reached */
24841 }
24842
zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)24843 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
24844 {
24845 USE_OPLINE
24846 zend_free_op free_op_data1;
24847 zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
24848 zval *object;
24849 zval *property = opline->op2.zv;
24850 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
24851 int have_get_ptr = 0;
24852
24853 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
24854 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
24855 }
24856
24857 make_real_object(object_ptr TSRMLS_CC);
24858 object = *object_ptr;
24859
24860 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24861 zend_error(E_WARNING, "Attempt to assign property of non-object");
24862
24863 FREE_OP(free_op_data1);
24864
24865 if (RETURN_VALUE_USED(opline)) {
24866 PZVAL_LOCK(&EG(uninitialized_zval));
24867 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
24868 }
24869 } else {
24870 /* here we are sure we are dealing with an object */
24871 if (0) {
24872 MAKE_REAL_ZVAL_PTR(property);
24873 }
24874
24875 /* here property is a string */
24876 if (opline->extended_value == ZEND_ASSIGN_OBJ
24877 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
24878 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
24879 if (zptr != NULL) { /* NULL means no success in getting PTR */
24880 have_get_ptr = 1;
24881 if (UNEXPECTED(*zptr == &EG(error_zval))) {
24882 if (RETURN_VALUE_USED(opline)) {
24883 PZVAL_LOCK(&EG(uninitialized_zval));
24884 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
24885 }
24886 } else {
24887 SEPARATE_ZVAL_IF_NOT_REF(zptr);
24888
24889 binary_op(*zptr, *zptr, value TSRMLS_CC);
24890 if (RETURN_VALUE_USED(opline)) {
24891 PZVAL_LOCK(*zptr);
24892 EX_T(opline->result.var).var.ptr = *zptr;
24893 }
24894 }
24895 }
24896 }
24897
24898 if (!have_get_ptr) {
24899 zval *z = NULL;
24900
24901 Z_ADDREF_P(object);
24902 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
24903 if (Z_OBJ_HT_P(object)->read_property) {
24904 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
24905 }
24906 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
24907 if (Z_OBJ_HT_P(object)->read_dimension) {
24908 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
24909 }
24910 }
24911 if (z) {
24912 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
24913 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
24914
24915 if (Z_REFCOUNT_P(z) == 0) {
24916 GC_REMOVE_ZVAL_FROM_BUFFER(z);
24917 zval_dtor(z);
24918 FREE_ZVAL(z);
24919 }
24920 z = value;
24921 }
24922 Z_ADDREF_P(z);
24923 SEPARATE_ZVAL_IF_NOT_REF(&z);
24924 binary_op(z, z, value TSRMLS_CC);
24925 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
24926 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
24927 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
24928 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
24929 }
24930 if (RETURN_VALUE_USED(opline)) {
24931 PZVAL_LOCK(z);
24932 EX_T(opline->result.var).var.ptr = z;
24933 }
24934 zval_ptr_dtor(&z);
24935 } else {
24936 zend_error(E_WARNING, "Attempt to assign property of non-object");
24937 if (RETURN_VALUE_USED(opline)) {
24938 PZVAL_LOCK(&EG(uninitialized_zval));
24939 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
24940 }
24941 }
24942 zval_ptr_dtor(&object);
24943 }
24944
24945 if (0) {
24946 zval_ptr_dtor(&property);
24947 } else {
24948
24949 }
24950 FREE_OP(free_op_data1);
24951 }
24952
24953 /* assign_obj has two opcodes! */
24954 CHECK_EXCEPTION();
24955 ZEND_VM_INC_OPCODE();
24956 ZEND_VM_NEXT_OPCODE();
24957 }
24958
zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)24959 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
24960 {
24961 USE_OPLINE
24962 zend_free_op free_op_data2, free_op_data1;
24963 zval **var_ptr;
24964 zval *value;
24965
24966 SAVE_OPLINE();
24967 switch (opline->extended_value) {
24968 case ZEND_ASSIGN_OBJ:
24969 return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24970 break;
24971 case ZEND_ASSIGN_DIM: {
24972 zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
24973
24974 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
24975 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
24976 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
24977 if (IS_UNUSED == IS_VAR && !0) {
24978 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
24979 }
24980 return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24981 } else {
24982 zval *dim = opline->op2.zv;
24983
24984 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC);
24985 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
24986 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
24987 }
24988 }
24989 break;
24990 default:
24991 value = opline->op2.zv;
24992 var_ptr = NULL;
24993 /* do nothing */
24994 break;
24995 }
24996
24997 if (UNEXPECTED(var_ptr == NULL)) {
24998 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
24999 }
25000
25001 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
25002 if (RETURN_VALUE_USED(opline)) {
25003 PZVAL_LOCK(&EG(uninitialized_zval));
25004 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
25005 }
25006
25007
25008 CHECK_EXCEPTION();
25009 if (opline->extended_value == ZEND_ASSIGN_DIM) {
25010 ZEND_VM_INC_OPCODE();
25011 }
25012 ZEND_VM_NEXT_OPCODE();
25013 }
25014
25015 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
25016
25017 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
25018 && Z_OBJ_HANDLER_PP(var_ptr, get)
25019 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
25020 /* proxy object */
25021 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
25022 Z_ADDREF_P(objval);
25023 binary_op(objval, objval, value TSRMLS_CC);
25024 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
25025 zval_ptr_dtor(&objval);
25026 } else {
25027 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
25028 }
25029
25030 if (RETURN_VALUE_USED(opline)) {
25031 PZVAL_LOCK(*var_ptr);
25032 EX_T(opline->result.var).var.ptr = *var_ptr;
25033 }
25034
25035 if (opline->extended_value == ZEND_ASSIGN_DIM) {
25036 FREE_OP(free_op_data1);
25037 FREE_OP_VAR_PTR(free_op_data2);
25038
25039 CHECK_EXCEPTION();
25040 ZEND_VM_INC_OPCODE();
25041 } else {
25042
25043 CHECK_EXCEPTION();
25044 }
25045 ZEND_VM_NEXT_OPCODE();
25046 }
25047
ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25048 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25049 {
25050 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25051 }
25052
ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25053 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25054 {
25055 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25056 }
25057
ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25058 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25059 {
25060 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25061 }
25062
ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25063 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25064 {
25065 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25066 }
25067
ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25068 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25069 {
25070 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25071 }
25072
ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25073 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25074 {
25075 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25076 }
25077
ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25078 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25079 {
25080 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25081 }
25082
ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25083 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25084 {
25085 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25086 }
25087
ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25088 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25089 {
25090 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25091 }
25092
ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25093 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25094 {
25095 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25096 }
25097
ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25098 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25099 {
25100 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25101 }
25102
zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)25103 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
25104 {
25105 USE_OPLINE
25106
25107 zval **object_ptr;
25108 zval *object;
25109 zval *property;
25110 zval **retval;
25111 int have_get_ptr = 0;
25112
25113 SAVE_OPLINE();
25114 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25115 property = opline->op2.zv;
25116 retval = &EX_T(opline->result.var).var.ptr;
25117
25118 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
25119 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
25120 }
25121
25122 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
25123 object = *object_ptr;
25124
25125 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
25126 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25127
25128 if (RETURN_VALUE_USED(opline)) {
25129 PZVAL_LOCK(&EG(uninitialized_zval));
25130 *retval = &EG(uninitialized_zval);
25131 }
25132
25133 CHECK_EXCEPTION();
25134 ZEND_VM_NEXT_OPCODE();
25135 }
25136
25137 /* here we are sure we are dealing with an object */
25138
25139 if (0) {
25140 MAKE_REAL_ZVAL_PTR(property);
25141 }
25142
25143 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
25144 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25145 if (zptr != NULL) { /* NULL means no success in getting PTR */
25146 have_get_ptr = 1;
25147 if (UNEXPECTED(*zptr == &EG(error_zval))) {
25148 if (RETURN_VALUE_USED(opline)) {
25149 PZVAL_LOCK(&EG(uninitialized_zval));
25150 *retval = &EG(uninitialized_zval);
25151 }
25152 } else {
25153 SEPARATE_ZVAL_IF_NOT_REF(zptr);
25154
25155 incdec_op(*zptr);
25156 if (RETURN_VALUE_USED(opline)) {
25157 *retval = *zptr;
25158 PZVAL_LOCK(*retval);
25159 }
25160 }
25161 }
25162 }
25163
25164 if (!have_get_ptr) {
25165 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
25166 zval *z;
25167
25168 Z_ADDREF_P(object);
25169 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25170
25171 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
25172 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
25173
25174 if (Z_REFCOUNT_P(z) == 0) {
25175 GC_REMOVE_ZVAL_FROM_BUFFER(z);
25176 zval_dtor(z);
25177 FREE_ZVAL(z);
25178 }
25179 z = value;
25180 }
25181 Z_ADDREF_P(z);
25182 SEPARATE_ZVAL_IF_NOT_REF(&z);
25183 incdec_op(z);
25184 *retval = z;
25185 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25186 zval_ptr_dtor(&object);
25187 SELECTIVE_PZVAL_LOCK(*retval, opline);
25188 zval_ptr_dtor(&z);
25189 } else {
25190 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25191 if (RETURN_VALUE_USED(opline)) {
25192 PZVAL_LOCK(&EG(uninitialized_zval));
25193 *retval = &EG(uninitialized_zval);
25194 }
25195 }
25196 }
25197
25198 if (0) {
25199 zval_ptr_dtor(&property);
25200 } else {
25201
25202 }
25203
25204 CHECK_EXCEPTION();
25205 ZEND_VM_NEXT_OPCODE();
25206 }
25207
ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25208 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25209 {
25210 return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25211 }
25212
ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25213 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25214 {
25215 return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25216 }
25217
zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)25218 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
25219 {
25220 USE_OPLINE
25221
25222 zval **object_ptr;
25223 zval *object;
25224 zval *property;
25225 zval *retval;
25226 int have_get_ptr = 0;
25227
25228 SAVE_OPLINE();
25229 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25230 property = opline->op2.zv;
25231 retval = &EX_T(opline->result.var).tmp_var;
25232
25233 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
25234 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
25235 }
25236
25237 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
25238 object = *object_ptr;
25239
25240 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
25241 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25242
25243 ZVAL_NULL(retval);
25244
25245 CHECK_EXCEPTION();
25246 ZEND_VM_NEXT_OPCODE();
25247 }
25248
25249 /* here we are sure we are dealing with an object */
25250
25251 if (0) {
25252 MAKE_REAL_ZVAL_PTR(property);
25253 }
25254
25255 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
25256 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25257 if (zptr != NULL) { /* NULL means no success in getting PTR */
25258 have_get_ptr = 1;
25259 if (UNEXPECTED(*zptr == &EG(error_zval))) {
25260 ZVAL_NULL(retval);
25261 } else {
25262 SEPARATE_ZVAL_IF_NOT_REF(zptr);
25263
25264 ZVAL_COPY_VALUE(retval, *zptr);
25265 zendi_zval_copy_ctor(*retval);
25266
25267 incdec_op(*zptr);
25268 }
25269 }
25270 }
25271
25272 if (!have_get_ptr) {
25273 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
25274 zval *z, *z_copy;
25275
25276 Z_ADDREF_P(object);
25277 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25278 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
25279 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
25280
25281 if (Z_REFCOUNT_P(z) == 0) {
25282 GC_REMOVE_ZVAL_FROM_BUFFER(z);
25283 zval_dtor(z);
25284 FREE_ZVAL(z);
25285 }
25286 z = value;
25287 }
25288 ZVAL_COPY_VALUE(retval, z);
25289 zendi_zval_copy_ctor(*retval);
25290 ALLOC_ZVAL(z_copy);
25291 INIT_PZVAL_COPY(z_copy, z);
25292 zendi_zval_copy_ctor(*z_copy);
25293 incdec_op(z_copy);
25294 Z_ADDREF_P(z);
25295 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25296 zval_ptr_dtor(&object);
25297 zval_ptr_dtor(&z_copy);
25298 zval_ptr_dtor(&z);
25299 } else {
25300 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25301 ZVAL_NULL(retval);
25302 }
25303 }
25304
25305 if (0) {
25306 zval_ptr_dtor(&property);
25307 } else {
25308
25309 }
25310
25311 CHECK_EXCEPTION();
25312 ZEND_VM_NEXT_OPCODE();
25313 }
25314
ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25315 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25316 {
25317 return zend_post_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25318 }
25319
ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25320 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25321 {
25322 return zend_post_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25323 }
25324
zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS)25325 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS)
25326 {
25327 USE_OPLINE
25328
25329 zval *container;
25330
25331 zval *offset;
25332
25333 SAVE_OPLINE();
25334 container = _get_obj_zval_ptr_unused(TSRMLS_C);
25335 offset = opline->op2.zv;
25336
25337 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
25338 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
25339 zend_error(E_NOTICE, "Trying to get property of non-object");
25340 PZVAL_LOCK(&EG(uninitialized_zval));
25341 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
25342
25343 } else {
25344 zval *retval;
25345
25346 if (0) {
25347 MAKE_REAL_ZVAL_PTR(offset);
25348 }
25349
25350 /* here we are sure we are dealing with an object */
25351 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25352
25353 PZVAL_LOCK(retval);
25354 EX_T(opline->result.var).var.ptr = retval;
25355
25356 if (0) {
25357 zval_ptr_dtor(&offset);
25358 } else {
25359
25360 }
25361 }
25362
25363 CHECK_EXCEPTION();
25364 ZEND_VM_NEXT_OPCODE();
25365 }
25366
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25367 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25368 {
25369 return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25370 }
25371
ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25372 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25373 {
25374 USE_OPLINE
25375 zend_free_op free_op1;
25376 zval *property;
25377 zval **container;
25378
25379 SAVE_OPLINE();
25380 property = opline->op2.zv;
25381
25382 if (0) {
25383 MAKE_REAL_ZVAL_PTR(property);
25384 }
25385 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25386 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
25387 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25388 }
25389
25390 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
25391 if (0) {
25392 zval_ptr_dtor(&property);
25393 } else {
25394
25395 }
25396 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
25397 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
25398 }
25399
25400 /* We are going to assign the result by reference */
25401 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
25402 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
25403
25404 Z_DELREF_PP(retval_ptr);
25405 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
25406 Z_ADDREF_PP(retval_ptr);
25407 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
25408 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
25409 }
25410
25411 CHECK_EXCEPTION();
25412 ZEND_VM_NEXT_OPCODE();
25413 }
25414
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25415 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25416 {
25417 USE_OPLINE
25418 zend_free_op free_op1;
25419 zval *property;
25420 zval **container;
25421
25422 SAVE_OPLINE();
25423 property = opline->op2.zv;
25424 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25425
25426 if (0) {
25427 MAKE_REAL_ZVAL_PTR(property);
25428 }
25429 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
25430 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25431 }
25432 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
25433 if (0) {
25434 zval_ptr_dtor(&property);
25435 } else {
25436
25437 }
25438 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
25439 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
25440 }
25441
25442 CHECK_EXCEPTION();
25443 ZEND_VM_NEXT_OPCODE();
25444 }
25445
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25446 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25447 {
25448 USE_OPLINE
25449
25450 zval *container;
25451
25452 zval *offset;
25453
25454 SAVE_OPLINE();
25455 container = _get_obj_zval_ptr_unused(TSRMLS_C);
25456 offset = opline->op2.zv;
25457
25458 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
25459 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
25460 PZVAL_LOCK(&EG(uninitialized_zval));
25461 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
25462
25463 } else {
25464 zval *retval;
25465
25466 if (0) {
25467 MAKE_REAL_ZVAL_PTR(offset);
25468 }
25469
25470 /* here we are sure we are dealing with an object */
25471 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25472
25473 PZVAL_LOCK(retval);
25474 EX_T(opline->result.var).var.ptr = retval;
25475
25476 if (0) {
25477 zval_ptr_dtor(&offset);
25478 } else {
25479
25480 }
25481 }
25482
25483 CHECK_EXCEPTION();
25484 ZEND_VM_NEXT_OPCODE();
25485 }
25486
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25487 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25488 {
25489 USE_OPLINE
25490
25491 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
25492 /* Behave like FETCH_OBJ_W */
25493 zend_free_op free_op1;
25494 zval *property;
25495 zval **container;
25496
25497 SAVE_OPLINE();
25498 property = opline->op2.zv;
25499 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25500
25501 if (0) {
25502 MAKE_REAL_ZVAL_PTR(property);
25503 }
25504 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
25505 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25506 }
25507 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
25508 if (0) {
25509 zval_ptr_dtor(&property);
25510 } else {
25511
25512 }
25513 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
25514 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
25515 }
25516
25517 CHECK_EXCEPTION();
25518 ZEND_VM_NEXT_OPCODE();
25519 } else {
25520 return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25521 }
25522 }
25523
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25524 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25525 {
25526 USE_OPLINE
25527 zend_free_op free_op1, free_res;
25528 zval **container;
25529 zval *property;
25530
25531 SAVE_OPLINE();
25532 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25533 property = opline->op2.zv;
25534
25535 if (IS_UNUSED == IS_CV) {
25536 if (container != &EG(uninitialized_zval_ptr)) {
25537 SEPARATE_ZVAL_IF_NOT_REF(container);
25538 }
25539 }
25540 if (0) {
25541 MAKE_REAL_ZVAL_PTR(property);
25542 }
25543 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
25544 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25545 }
25546 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
25547 if (0) {
25548 zval_ptr_dtor(&property);
25549 } else {
25550
25551 }
25552 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
25553 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
25554 }
25555
25556 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
25557 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
25558 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
25559 }
25560 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
25561 FREE_OP_VAR_PTR(free_res);
25562 CHECK_EXCEPTION();
25563 ZEND_VM_NEXT_OPCODE();
25564 }
25565
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25566 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25567 {
25568 USE_OPLINE
25569
25570 zval **object_ptr;
25571 zval *property_name;
25572
25573 SAVE_OPLINE();
25574 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25575 property_name = opline->op2.zv;
25576
25577 if (0) {
25578 MAKE_REAL_ZVAL_PTR(property_name);
25579 }
25580 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
25581 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25582 }
25583 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25584 if (0) {
25585 zval_ptr_dtor(&property_name);
25586 } else {
25587
25588 }
25589
25590 /* assign_obj has two opcodes! */
25591 CHECK_EXCEPTION();
25592 ZEND_VM_INC_OPCODE();
25593 ZEND_VM_NEXT_OPCODE();
25594 }
25595
ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25596 static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25597 {
25598 USE_OPLINE
25599 zval *str = &EX_T(opline->result.var).tmp_var;
25600
25601 SAVE_OPLINE();
25602
25603 if (IS_UNUSED == IS_UNUSED) {
25604 /* Initialize for erealloc in add_char_to_string */
25605 Z_STRVAL_P(str) = NULL;
25606 Z_STRLEN_P(str) = 0;
25607 Z_TYPE_P(str) = IS_STRING;
25608
25609 INIT_PZVAL(str);
25610 }
25611
25612 add_char_to_string(str, str, opline->op2.zv);
25613
25614 /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
25615 /*CHECK_EXCEPTION();*/
25616 ZEND_VM_NEXT_OPCODE();
25617 }
25618
ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25619 static int ZEND_FASTCALL ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25620 {
25621 USE_OPLINE
25622 zval *str = &EX_T(opline->result.var).tmp_var;
25623
25624 SAVE_OPLINE();
25625
25626 if (IS_UNUSED == IS_UNUSED) {
25627 /* Initialize for erealloc in add_string_to_string */
25628 Z_STRVAL_P(str) = NULL;
25629 Z_STRLEN_P(str) = 0;
25630 Z_TYPE_P(str) = IS_STRING;
25631
25632 INIT_PZVAL(str);
25633 }
25634
25635 add_string_to_string(str, str, opline->op2.zv);
25636
25637 /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
25638 /*CHECK_EXCEPTION();*/
25639 ZEND_VM_NEXT_OPCODE();
25640 }
25641
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25642 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25643 {
25644 USE_OPLINE
25645 zval *function_name;
25646 char *function_name_strval;
25647 int function_name_strlen;
25648
25649 call_slot *call = EX(call_slots) + opline->result.num;
25650
25651 SAVE_OPLINE();
25652
25653 function_name = opline->op2.zv;
25654
25655 if (IS_CONST != IS_CONST &&
25656 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
25657 if (UNEXPECTED(EG(exception) != NULL)) {
25658 HANDLE_EXCEPTION();
25659 }
25660 zend_error_noreturn(E_ERROR, "Method name must be a string");
25661 }
25662
25663 function_name_strval = Z_STRVAL_P(function_name);
25664 function_name_strlen = Z_STRLEN_P(function_name);
25665
25666 call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
25667
25668 if (EXPECTED(call->object != NULL) &&
25669 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
25670 call->called_scope = Z_OBJCE_P(call->object);
25671
25672 if (IS_CONST != IS_CONST ||
25673 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
25674 zval *object = call->object;
25675
25676 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
25677 zend_error_noreturn(E_ERROR, "Object does not support method calls");
25678 }
25679
25680 /* First, locate the function. */
25681 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
25682 if (UNEXPECTED(call->fbc == NULL)) {
25683 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
25684 }
25685 if (IS_CONST == IS_CONST &&
25686 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
25687 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
25688 EXPECTED(call->object == object)) {
25689 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
25690 }
25691 }
25692 } else {
25693 if (UNEXPECTED(EG(exception) != NULL)) {
25694
25695 HANDLE_EXCEPTION();
25696 }
25697 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
25698 }
25699
25700 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
25701 call->object = NULL;
25702 } else {
25703 if (!PZVAL_IS_REF(call->object)) {
25704 Z_ADDREF_P(call->object); /* For $this pointer */
25705 } else {
25706 zval *this_ptr;
25707 ALLOC_ZVAL(this_ptr);
25708 INIT_PZVAL_COPY(this_ptr, call->object);
25709 zval_copy_ctor(this_ptr);
25710 call->object = this_ptr;
25711 }
25712 }
25713
25714 call->num_additional_args = 0;
25715 call->is_ctor_call = 0;
25716 EX(call) = call;
25717
25718
25719 CHECK_EXCEPTION();
25720 ZEND_VM_NEXT_OPCODE();
25721 }
25722
ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25723 static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25724 {
25725 USE_OPLINE
25726
25727 SAVE_OPLINE();
25728 if (IS_UNUSED == IS_UNUSED) {
25729 zend_constant *c;
25730 zval *retval;
25731
25732 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
25733 c = CACHED_PTR(opline->op2.literal->cache_slot);
25734 } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
25735 if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
25736 char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
25737 if(!actual) {
25738 actual = Z_STRVAL_P(opline->op2.zv);
25739 } else {
25740 actual++;
25741 }
25742 /* non-qualified constant - allow text substitution */
25743 zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
25744 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
25745 CHECK_EXCEPTION();
25746 ZEND_VM_NEXT_OPCODE();
25747 } else {
25748 zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
25749 }
25750 } else {
25751 CACHE_PTR(opline->op2.literal->cache_slot, c);
25752 }
25753 retval = &EX_T(opline->result.var).tmp_var;
25754 ZVAL_COPY_VALUE(retval, &c->value);
25755 zval_copy_ctor(retval);
25756 } else {
25757 /* class constant */
25758 zend_class_entry *ce;
25759 zval **value;
25760
25761 if (IS_UNUSED == IS_CONST) {
25762 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
25763 value = CACHED_PTR(opline->op2.literal->cache_slot);
25764 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
25765 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
25766 goto constant_fetch_end;
25767 } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
25768 ce = CACHED_PTR(opline->op1.literal->cache_slot);
25769 } else {
25770 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
25771 if (UNEXPECTED(EG(exception) != NULL)) {
25772 HANDLE_EXCEPTION();
25773 }
25774 if (UNEXPECTED(ce == NULL)) {
25775 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
25776 }
25777 CACHE_PTR(opline->op1.literal->cache_slot, ce);
25778 }
25779 } else {
25780 ce = EX_T(opline->op1.var).class_entry;
25781 if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
25782 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
25783 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
25784 goto constant_fetch_end;
25785 }
25786 }
25787
25788 if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) {
25789 if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
25790 zend_class_entry *old_scope = EG(scope);
25791
25792 EG(scope) = ce;
25793 zval_update_constant(value, 1 TSRMLS_CC);
25794 EG(scope) = old_scope;
25795 }
25796 if (IS_UNUSED == IS_CONST) {
25797 CACHE_PTR(opline->op2.literal->cache_slot, value);
25798 } else {
25799 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
25800 }
25801 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
25802 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
25803 } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
25804 /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
25805 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
25806 } else {
25807 zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
25808 }
25809 }
25810 constant_fetch_end:
25811 CHECK_EXCEPTION();
25812 ZEND_VM_NEXT_OPCODE();
25813 }
25814
ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25815 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25816 {
25817 USE_OPLINE
25818
25819 array_init(&EX_T(opline->result.var).tmp_var);
25820 if (IS_UNUSED == IS_UNUSED) {
25821 ZEND_VM_NEXT_OPCODE();
25822 #if 0 || IS_UNUSED != IS_UNUSED
25823 } else {
25824 return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25825 #endif
25826 }
25827 }
25828
ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25829 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25830 {
25831 USE_OPLINE
25832
25833 zval **container;
25834 zval *offset;
25835 ulong hval;
25836
25837 SAVE_OPLINE();
25838 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25839 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
25840 SEPARATE_ZVAL_IF_NOT_REF(container);
25841 }
25842 offset = opline->op2.zv;
25843
25844 if (IS_UNUSED != IS_VAR || container) {
25845 switch (Z_TYPE_PP(container)) {
25846 case IS_ARRAY: {
25847 HashTable *ht = Z_ARRVAL_PP(container);
25848
25849 switch (Z_TYPE_P(offset)) {
25850 case IS_DOUBLE:
25851 hval = zend_dval_to_lval(Z_DVAL_P(offset));
25852 zend_hash_index_del(ht, hval);
25853 break;
25854 case IS_RESOURCE:
25855 case IS_BOOL:
25856 case IS_LONG:
25857 hval = Z_LVAL_P(offset);
25858 zend_hash_index_del(ht, hval);
25859 break;
25860 case IS_STRING:
25861 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
25862 Z_ADDREF_P(offset);
25863 }
25864 if (IS_CONST == IS_CONST) {
25865 hval = Z_HASH_P(offset);
25866 } else {
25867 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
25868 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
25869 }
25870 if (ht == &EG(symbol_table)) {
25871 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
25872 } else {
25873 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
25874 }
25875 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
25876 zval_ptr_dtor(&offset);
25877 }
25878 break;
25879 num_index_dim:
25880 zend_hash_index_del(ht, hval);
25881 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
25882 zval_ptr_dtor(&offset);
25883 }
25884 break;
25885 case IS_NULL:
25886 zend_hash_del(ht, "", sizeof(""));
25887 break;
25888 default:
25889 zend_error(E_WARNING, "Illegal offset type in unset");
25890 break;
25891 }
25892
25893 break;
25894 }
25895 case IS_OBJECT:
25896 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
25897 zend_error_noreturn(E_ERROR, "Cannot use object as array");
25898 }
25899 if (0) {
25900 MAKE_REAL_ZVAL_PTR(offset);
25901 }
25902 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
25903 if (0) {
25904 zval_ptr_dtor(&offset);
25905 } else {
25906
25907 }
25908 break;
25909 case IS_STRING:
25910 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
25911 ZEND_VM_CONTINUE(); /* bailed out before */
25912 default:
25913
25914 break;
25915 }
25916 } else {
25917
25918 }
25919
25920 CHECK_EXCEPTION();
25921 ZEND_VM_NEXT_OPCODE();
25922 }
25923
ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25924 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25925 {
25926 USE_OPLINE
25927
25928 zval **container;
25929 zval *offset;
25930
25931 SAVE_OPLINE();
25932 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25933 offset = opline->op2.zv;
25934
25935 if (IS_UNUSED != IS_VAR || container) {
25936 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
25937 SEPARATE_ZVAL_IF_NOT_REF(container);
25938 }
25939 if (Z_TYPE_PP(container) == IS_OBJECT) {
25940 if (0) {
25941 MAKE_REAL_ZVAL_PTR(offset);
25942 }
25943 if (Z_OBJ_HT_P(*container)->unset_property) {
25944 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25945 } else {
25946 zend_error(E_NOTICE, "Trying to unset property of non-object");
25947 }
25948 if (0) {
25949 zval_ptr_dtor(&offset);
25950 } else {
25951
25952 }
25953 } else {
25954
25955 }
25956 } else {
25957
25958 }
25959
25960 CHECK_EXCEPTION();
25961 ZEND_VM_NEXT_OPCODE();
25962 }
25963
zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)25964 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
25965 {
25966 USE_OPLINE
25967
25968 zval *container;
25969 zval **value = NULL;
25970 int result = 0;
25971 ulong hval;
25972 zval *offset;
25973
25974 SAVE_OPLINE();
25975 container = _get_obj_zval_ptr_unused(TSRMLS_C);
25976 offset = opline->op2.zv;
25977
25978 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
25979 HashTable *ht;
25980 int isset = 0;
25981
25982 ht = Z_ARRVAL_P(container);
25983
25984 switch (Z_TYPE_P(offset)) {
25985 case IS_DOUBLE:
25986 hval = zend_dval_to_lval(Z_DVAL_P(offset));
25987 goto num_index_prop;
25988 case IS_RESOURCE:
25989 case IS_BOOL:
25990 case IS_LONG:
25991 hval = Z_LVAL_P(offset);
25992 num_index_prop:
25993 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
25994 isset = 1;
25995 }
25996 break;
25997 case IS_STRING:
25998 if (IS_CONST == IS_CONST) {
25999 hval = Z_HASH_P(offset);
26000 } else {
26001 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
26002 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
26003 }
26004 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
26005 isset = 1;
26006 }
26007 break;
26008 case IS_NULL:
26009 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
26010 isset = 1;
26011 }
26012 break;
26013 default:
26014 zend_error(E_WARNING, "Illegal offset type in isset or empty");
26015 break;
26016 }
26017
26018 if (opline->extended_value & ZEND_ISSET) {
26019 if (isset && Z_TYPE_PP(value) == IS_NULL) {
26020 result = 0;
26021 } else {
26022 result = isset;
26023 }
26024 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
26025 if (!isset || !i_zend_is_true(*value)) {
26026 result = 0;
26027 } else {
26028 result = 1;
26029 }
26030 }
26031
26032 } else if (Z_TYPE_P(container) == IS_OBJECT) {
26033 if (0) {
26034 MAKE_REAL_ZVAL_PTR(offset);
26035 }
26036 if (prop_dim) {
26037 if (Z_OBJ_HT_P(container)->has_property) {
26038 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26039 } else {
26040 zend_error(E_NOTICE, "Trying to check property of non-object");
26041 result = 0;
26042 }
26043 } else {
26044 if (Z_OBJ_HT_P(container)->has_dimension) {
26045 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
26046 } else {
26047 zend_error(E_NOTICE, "Trying to check element of non-array");
26048 result = 0;
26049 }
26050 }
26051 if (0) {
26052 zval_ptr_dtor(&offset);
26053 } else {
26054
26055 }
26056 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
26057 zval tmp;
26058
26059 if (Z_TYPE_P(offset) != IS_LONG) {
26060 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
26061 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
26062 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
26063 ZVAL_COPY_VALUE(&tmp, offset);
26064 zval_copy_ctor(&tmp);
26065 convert_to_long(&tmp);
26066 offset = &tmp;
26067 } else {
26068 /* can not be converted to proper offset, return "not set" */
26069 result = 0;
26070 }
26071 }
26072 if (Z_TYPE_P(offset) == IS_LONG) {
26073 if (opline->extended_value & ZEND_ISSET) {
26074 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
26075 result = 1;
26076 }
26077 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
26078 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
26079 result = 1;
26080 }
26081 }
26082 }
26083
26084 } else {
26085
26086 }
26087
26088 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
26089 if (opline->extended_value & ZEND_ISSET) {
26090 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
26091 } else {
26092 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
26093 }
26094
26095 CHECK_EXCEPTION();
26096 ZEND_VM_NEXT_OPCODE();
26097 }
26098
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26099 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26100 {
26101 return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26102 }
26103
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26104 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26105 {
26106 return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26107 }
26108
ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26109 static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26110 {
26111 USE_OPLINE
26112
26113 /* The generator object is stored in return_value_ptr_ptr */
26114 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
26115
26116 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
26117 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
26118 }
26119
26120 /* Destroy the previously yielded value */
26121 if (generator->value) {
26122 zval_ptr_dtor(&generator->value);
26123 }
26124
26125 /* Destroy the previously yielded key */
26126 if (generator->key) {
26127 zval_ptr_dtor(&generator->key);
26128 }
26129
26130 /* Set the new yielded value */
26131 if (IS_UNUSED != IS_UNUSED) {
26132
26133
26134 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
26135 /* Constants and temporary variables aren't yieldable by reference,
26136 * but we still allow them with a notice. */
26137 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
26138 zval *value, *copy;
26139
26140 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26141
26142 value = NULL;
26143 ALLOC_ZVAL(copy);
26144 INIT_PZVAL_COPY(copy, value);
26145
26146 /* Temporary variables don't need ctor copying */
26147 if (!0) {
26148 zval_copy_ctor(copy);
26149 }
26150
26151 generator->value = copy;
26152 } else {
26153 zval **value_ptr = NULL;
26154
26155 if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
26156 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
26157 }
26158
26159 /* If a function call result is yielded and the function did
26160 * not return by reference we throw a notice. */
26161 if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
26162 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
26163 && EX_T(opline->op1.var).var.fcall_returned_reference)
26164 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
26165 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26166
26167 Z_ADDREF_PP(value_ptr);
26168 generator->value = *value_ptr;
26169 } else {
26170 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
26171 Z_ADDREF_PP(value_ptr);
26172 generator->value = *value_ptr;
26173 }
26174
26175 }
26176 } else {
26177 zval *value = NULL;
26178
26179 /* Consts, temporary variables and references need copying */
26180 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
26181 || PZVAL_IS_REF(value)
26182 ) {
26183 zval *copy;
26184
26185 ALLOC_ZVAL(copy);
26186 INIT_PZVAL_COPY(copy, value);
26187
26188 /* Temporary variables don't need ctor copying */
26189 if (!0) {
26190 zval_copy_ctor(copy);
26191 }
26192
26193 generator->value = copy;
26194
26195 } else {
26196 if (IS_UNUSED == IS_CV) {
26197 Z_ADDREF_P(value);
26198 }
26199 generator->value = value;
26200 }
26201 }
26202 } else {
26203 /* If no value was specified yield null */
26204 Z_ADDREF(EG(uninitialized_zval));
26205 generator->value = &EG(uninitialized_zval);
26206 }
26207
26208 /* Set the new yielded key */
26209 if (IS_CONST != IS_UNUSED) {
26210
26211 zval *key = opline->op2.zv;
26212
26213 /* Consts, temporary variables and references need copying */
26214 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
26215 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
26216 ) {
26217 zval *copy;
26218
26219 ALLOC_ZVAL(copy);
26220 INIT_PZVAL_COPY(copy, key);
26221
26222 /* Temporary variables don't need ctor copying */
26223 if (!0) {
26224 zval_copy_ctor(copy);
26225 }
26226
26227 generator->key = copy;
26228 } else {
26229 Z_ADDREF_P(key);
26230 generator->key = key;
26231 }
26232
26233 if (Z_TYPE_P(generator->key) == IS_LONG
26234 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
26235 ) {
26236 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
26237 }
26238
26239 } else {
26240 /* If no key was specified we use auto-increment keys */
26241 generator->largest_used_integer_key++;
26242
26243 ALLOC_INIT_ZVAL(generator->key);
26244 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
26245 }
26246
26247 if (RETURN_VALUE_USED(opline)) {
26248 /* If the return value of yield is used set the send
26249 * target and initialize it to NULL */
26250 generator->send_target = &EX_T(opline->result.var).var.ptr;
26251 Z_ADDREF(EG(uninitialized_zval));
26252 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26253 } else {
26254 generator->send_target = NULL;
26255 }
26256
26257 /* We increment to the next op, so we are at the correct position when the
26258 * generator is resumed. */
26259 ZEND_VM_INC_OPCODE();
26260
26261 /* The GOTO VM uses a local opline variable. We need to set the opline
26262 * variable in execute_data so we don't resume at an old position. */
26263 SAVE_OPLINE();
26264
26265 ZEND_VM_RETURN();
26266 }
26267
ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26268 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26269 {
26270 return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26271 }
26272
zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)26273 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
26274 {
26275 USE_OPLINE
26276 zend_free_op free_op2, free_op_data1;
26277 zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26278 zval *object;
26279 zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26280 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
26281 int have_get_ptr = 0;
26282
26283 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
26284 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26285 }
26286
26287 make_real_object(object_ptr TSRMLS_CC);
26288 object = *object_ptr;
26289
26290 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26291 zend_error(E_WARNING, "Attempt to assign property of non-object");
26292 zval_dtor(free_op2.var);
26293 FREE_OP(free_op_data1);
26294
26295 if (RETURN_VALUE_USED(opline)) {
26296 PZVAL_LOCK(&EG(uninitialized_zval));
26297 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26298 }
26299 } else {
26300 /* here we are sure we are dealing with an object */
26301 if (1) {
26302 MAKE_REAL_ZVAL_PTR(property);
26303 }
26304
26305 /* here property is a string */
26306 if (opline->extended_value == ZEND_ASSIGN_OBJ
26307 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
26308 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26309 if (zptr != NULL) { /* NULL means no success in getting PTR */
26310 have_get_ptr = 1;
26311 if (UNEXPECTED(*zptr == &EG(error_zval))) {
26312 if (RETURN_VALUE_USED(opline)) {
26313 PZVAL_LOCK(&EG(uninitialized_zval));
26314 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26315 }
26316 } else {
26317 SEPARATE_ZVAL_IF_NOT_REF(zptr);
26318
26319 binary_op(*zptr, *zptr, value TSRMLS_CC);
26320 if (RETURN_VALUE_USED(opline)) {
26321 PZVAL_LOCK(*zptr);
26322 EX_T(opline->result.var).var.ptr = *zptr;
26323 }
26324 }
26325 }
26326 }
26327
26328 if (!have_get_ptr) {
26329 zval *z = NULL;
26330
26331 Z_ADDREF_P(object);
26332 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
26333 if (Z_OBJ_HT_P(object)->read_property) {
26334 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26335 }
26336 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
26337 if (Z_OBJ_HT_P(object)->read_dimension) {
26338 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
26339 }
26340 }
26341 if (z) {
26342 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
26343 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
26344
26345 if (Z_REFCOUNT_P(z) == 0) {
26346 GC_REMOVE_ZVAL_FROM_BUFFER(z);
26347 zval_dtor(z);
26348 FREE_ZVAL(z);
26349 }
26350 z = value;
26351 }
26352 Z_ADDREF_P(z);
26353 SEPARATE_ZVAL_IF_NOT_REF(&z);
26354 binary_op(z, z, value TSRMLS_CC);
26355 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
26356 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26357 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
26358 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
26359 }
26360 if (RETURN_VALUE_USED(opline)) {
26361 PZVAL_LOCK(z);
26362 EX_T(opline->result.var).var.ptr = z;
26363 }
26364 zval_ptr_dtor(&z);
26365 } else {
26366 zend_error(E_WARNING, "Attempt to assign property of non-object");
26367 if (RETURN_VALUE_USED(opline)) {
26368 PZVAL_LOCK(&EG(uninitialized_zval));
26369 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26370 }
26371 }
26372 zval_ptr_dtor(&object);
26373 }
26374
26375 if (1) {
26376 zval_ptr_dtor(&property);
26377 } else {
26378 zval_dtor(free_op2.var);
26379 }
26380 FREE_OP(free_op_data1);
26381 }
26382
26383 /* assign_obj has two opcodes! */
26384 CHECK_EXCEPTION();
26385 ZEND_VM_INC_OPCODE();
26386 ZEND_VM_NEXT_OPCODE();
26387 }
26388
zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)26389 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
26390 {
26391 USE_OPLINE
26392 zend_free_op free_op2, free_op_data2, free_op_data1;
26393 zval **var_ptr;
26394 zval *value;
26395
26396 SAVE_OPLINE();
26397 switch (opline->extended_value) {
26398 case ZEND_ASSIGN_OBJ:
26399 return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26400 break;
26401 case ZEND_ASSIGN_DIM: {
26402 zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26403
26404 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
26405 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26406 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
26407 if (IS_UNUSED == IS_VAR && !0) {
26408 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
26409 }
26410 return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26411 } else {
26412 zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26413
26414 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
26415 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
26416 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
26417 }
26418 }
26419 break;
26420 default:
26421 value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26422 var_ptr = NULL;
26423 /* do nothing */
26424 break;
26425 }
26426
26427 if (UNEXPECTED(var_ptr == NULL)) {
26428 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
26429 }
26430
26431 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
26432 if (RETURN_VALUE_USED(opline)) {
26433 PZVAL_LOCK(&EG(uninitialized_zval));
26434 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26435 }
26436 zval_dtor(free_op2.var);
26437
26438 CHECK_EXCEPTION();
26439 if (opline->extended_value == ZEND_ASSIGN_DIM) {
26440 ZEND_VM_INC_OPCODE();
26441 }
26442 ZEND_VM_NEXT_OPCODE();
26443 }
26444
26445 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
26446
26447 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
26448 && Z_OBJ_HANDLER_PP(var_ptr, get)
26449 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
26450 /* proxy object */
26451 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
26452 Z_ADDREF_P(objval);
26453 binary_op(objval, objval, value TSRMLS_CC);
26454 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
26455 zval_ptr_dtor(&objval);
26456 } else {
26457 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
26458 }
26459
26460 if (RETURN_VALUE_USED(opline)) {
26461 PZVAL_LOCK(*var_ptr);
26462 EX_T(opline->result.var).var.ptr = *var_ptr;
26463 }
26464 zval_dtor(free_op2.var);
26465
26466 if (opline->extended_value == ZEND_ASSIGN_DIM) {
26467 FREE_OP(free_op_data1);
26468 FREE_OP_VAR_PTR(free_op_data2);
26469
26470 CHECK_EXCEPTION();
26471 ZEND_VM_INC_OPCODE();
26472 } else {
26473
26474 CHECK_EXCEPTION();
26475 }
26476 ZEND_VM_NEXT_OPCODE();
26477 }
26478
ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26479 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26480 {
26481 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26482 }
26483
ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26484 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26485 {
26486 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26487 }
26488
ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26489 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26490 {
26491 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26492 }
26493
ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26494 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26495 {
26496 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26497 }
26498
ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26499 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26500 {
26501 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26502 }
26503
ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26504 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26505 {
26506 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26507 }
26508
ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26509 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26510 {
26511 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26512 }
26513
ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26514 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26515 {
26516 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26517 }
26518
ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26519 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26520 {
26521 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26522 }
26523
ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26524 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26525 {
26526 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26527 }
26528
ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26529 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26530 {
26531 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26532 }
26533
zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)26534 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
26535 {
26536 USE_OPLINE
26537 zend_free_op free_op2;
26538 zval **object_ptr;
26539 zval *object;
26540 zval *property;
26541 zval **retval;
26542 int have_get_ptr = 0;
26543
26544 SAVE_OPLINE();
26545 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26546 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26547 retval = &EX_T(opline->result.var).var.ptr;
26548
26549 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
26550 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
26551 }
26552
26553 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
26554 object = *object_ptr;
26555
26556 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26557 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26558 zval_dtor(free_op2.var);
26559 if (RETURN_VALUE_USED(opline)) {
26560 PZVAL_LOCK(&EG(uninitialized_zval));
26561 *retval = &EG(uninitialized_zval);
26562 }
26563
26564 CHECK_EXCEPTION();
26565 ZEND_VM_NEXT_OPCODE();
26566 }
26567
26568 /* here we are sure we are dealing with an object */
26569
26570 if (1) {
26571 MAKE_REAL_ZVAL_PTR(property);
26572 }
26573
26574 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
26575 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26576 if (zptr != NULL) { /* NULL means no success in getting PTR */
26577 have_get_ptr = 1;
26578 if (UNEXPECTED(*zptr == &EG(error_zval))) {
26579 if (RETURN_VALUE_USED(opline)) {
26580 PZVAL_LOCK(&EG(uninitialized_zval));
26581 *retval = &EG(uninitialized_zval);
26582 }
26583 } else {
26584 SEPARATE_ZVAL_IF_NOT_REF(zptr);
26585
26586 incdec_op(*zptr);
26587 if (RETURN_VALUE_USED(opline)) {
26588 *retval = *zptr;
26589 PZVAL_LOCK(*retval);
26590 }
26591 }
26592 }
26593 }
26594
26595 if (!have_get_ptr) {
26596 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
26597 zval *z;
26598
26599 Z_ADDREF_P(object);
26600 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26601
26602 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
26603 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
26604
26605 if (Z_REFCOUNT_P(z) == 0) {
26606 GC_REMOVE_ZVAL_FROM_BUFFER(z);
26607 zval_dtor(z);
26608 FREE_ZVAL(z);
26609 }
26610 z = value;
26611 }
26612 Z_ADDREF_P(z);
26613 SEPARATE_ZVAL_IF_NOT_REF(&z);
26614 incdec_op(z);
26615 *retval = z;
26616 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26617 zval_ptr_dtor(&object);
26618 SELECTIVE_PZVAL_LOCK(*retval, opline);
26619 zval_ptr_dtor(&z);
26620 } else {
26621 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26622 if (RETURN_VALUE_USED(opline)) {
26623 PZVAL_LOCK(&EG(uninitialized_zval));
26624 *retval = &EG(uninitialized_zval);
26625 }
26626 }
26627 }
26628
26629 if (1) {
26630 zval_ptr_dtor(&property);
26631 } else {
26632 zval_dtor(free_op2.var);
26633 }
26634
26635 CHECK_EXCEPTION();
26636 ZEND_VM_NEXT_OPCODE();
26637 }
26638
ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26639 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26640 {
26641 return zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26642 }
26643
ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26644 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26645 {
26646 return zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26647 }
26648
zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)26649 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
26650 {
26651 USE_OPLINE
26652 zend_free_op free_op2;
26653 zval **object_ptr;
26654 zval *object;
26655 zval *property;
26656 zval *retval;
26657 int have_get_ptr = 0;
26658
26659 SAVE_OPLINE();
26660 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26661 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26662 retval = &EX_T(opline->result.var).tmp_var;
26663
26664 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
26665 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
26666 }
26667
26668 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
26669 object = *object_ptr;
26670
26671 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26672 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26673 zval_dtor(free_op2.var);
26674 ZVAL_NULL(retval);
26675
26676 CHECK_EXCEPTION();
26677 ZEND_VM_NEXT_OPCODE();
26678 }
26679
26680 /* here we are sure we are dealing with an object */
26681
26682 if (1) {
26683 MAKE_REAL_ZVAL_PTR(property);
26684 }
26685
26686 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
26687 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26688 if (zptr != NULL) { /* NULL means no success in getting PTR */
26689 have_get_ptr = 1;
26690 if (UNEXPECTED(*zptr == &EG(error_zval))) {
26691 ZVAL_NULL(retval);
26692 } else {
26693 SEPARATE_ZVAL_IF_NOT_REF(zptr);
26694
26695 ZVAL_COPY_VALUE(retval, *zptr);
26696 zendi_zval_copy_ctor(*retval);
26697
26698 incdec_op(*zptr);
26699 }
26700 }
26701 }
26702
26703 if (!have_get_ptr) {
26704 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
26705 zval *z, *z_copy;
26706
26707 Z_ADDREF_P(object);
26708 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26709 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
26710 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
26711
26712 if (Z_REFCOUNT_P(z) == 0) {
26713 GC_REMOVE_ZVAL_FROM_BUFFER(z);
26714 zval_dtor(z);
26715 FREE_ZVAL(z);
26716 }
26717 z = value;
26718 }
26719 ZVAL_COPY_VALUE(retval, z);
26720 zendi_zval_copy_ctor(*retval);
26721 ALLOC_ZVAL(z_copy);
26722 INIT_PZVAL_COPY(z_copy, z);
26723 zendi_zval_copy_ctor(*z_copy);
26724 incdec_op(z_copy);
26725 Z_ADDREF_P(z);
26726 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26727 zval_ptr_dtor(&object);
26728 zval_ptr_dtor(&z_copy);
26729 zval_ptr_dtor(&z);
26730 } else {
26731 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26732 ZVAL_NULL(retval);
26733 }
26734 }
26735
26736 if (1) {
26737 zval_ptr_dtor(&property);
26738 } else {
26739 zval_dtor(free_op2.var);
26740 }
26741
26742 CHECK_EXCEPTION();
26743 ZEND_VM_NEXT_OPCODE();
26744 }
26745
ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26746 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26747 {
26748 return zend_post_incdec_property_helper_SPEC_UNUSED_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26749 }
26750
ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26751 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26752 {
26753 return zend_post_incdec_property_helper_SPEC_UNUSED_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26754 }
26755
zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS)26756 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS)
26757 {
26758 USE_OPLINE
26759
26760 zval *container;
26761 zend_free_op free_op2;
26762 zval *offset;
26763
26764 SAVE_OPLINE();
26765 container = _get_obj_zval_ptr_unused(TSRMLS_C);
26766 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26767
26768 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
26769 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
26770 zend_error(E_NOTICE, "Trying to get property of non-object");
26771 PZVAL_LOCK(&EG(uninitialized_zval));
26772 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26773 zval_dtor(free_op2.var);
26774 } else {
26775 zval *retval;
26776
26777 if (1) {
26778 MAKE_REAL_ZVAL_PTR(offset);
26779 }
26780
26781 /* here we are sure we are dealing with an object */
26782 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26783
26784 PZVAL_LOCK(retval);
26785 EX_T(opline->result.var).var.ptr = retval;
26786
26787 if (1) {
26788 zval_ptr_dtor(&offset);
26789 } else {
26790 zval_dtor(free_op2.var);
26791 }
26792 }
26793
26794 CHECK_EXCEPTION();
26795 ZEND_VM_NEXT_OPCODE();
26796 }
26797
ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26798 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26799 {
26800 return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26801 }
26802
ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26803 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26804 {
26805 USE_OPLINE
26806 zend_free_op free_op1, free_op2;
26807 zval *property;
26808 zval **container;
26809
26810 SAVE_OPLINE();
26811 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26812
26813 if (1) {
26814 MAKE_REAL_ZVAL_PTR(property);
26815 }
26816 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26817 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
26818 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26819 }
26820
26821 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
26822 if (1) {
26823 zval_ptr_dtor(&property);
26824 } else {
26825 zval_dtor(free_op2.var);
26826 }
26827 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
26828 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
26829 }
26830
26831 /* We are going to assign the result by reference */
26832 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
26833 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
26834
26835 Z_DELREF_PP(retval_ptr);
26836 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
26837 Z_ADDREF_PP(retval_ptr);
26838 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
26839 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
26840 }
26841
26842 CHECK_EXCEPTION();
26843 ZEND_VM_NEXT_OPCODE();
26844 }
26845
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26846 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26847 {
26848 USE_OPLINE
26849 zend_free_op free_op1, free_op2;
26850 zval *property;
26851 zval **container;
26852
26853 SAVE_OPLINE();
26854 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26855 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26856
26857 if (1) {
26858 MAKE_REAL_ZVAL_PTR(property);
26859 }
26860 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
26861 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26862 }
26863 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
26864 if (1) {
26865 zval_ptr_dtor(&property);
26866 } else {
26867 zval_dtor(free_op2.var);
26868 }
26869 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
26870 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
26871 }
26872
26873 CHECK_EXCEPTION();
26874 ZEND_VM_NEXT_OPCODE();
26875 }
26876
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26877 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26878 {
26879 USE_OPLINE
26880
26881 zval *container;
26882 zend_free_op free_op2;
26883 zval *offset;
26884
26885 SAVE_OPLINE();
26886 container = _get_obj_zval_ptr_unused(TSRMLS_C);
26887 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26888
26889 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
26890 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
26891 PZVAL_LOCK(&EG(uninitialized_zval));
26892 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26893 zval_dtor(free_op2.var);
26894 } else {
26895 zval *retval;
26896
26897 if (1) {
26898 MAKE_REAL_ZVAL_PTR(offset);
26899 }
26900
26901 /* here we are sure we are dealing with an object */
26902 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26903
26904 PZVAL_LOCK(retval);
26905 EX_T(opline->result.var).var.ptr = retval;
26906
26907 if (1) {
26908 zval_ptr_dtor(&offset);
26909 } else {
26910 zval_dtor(free_op2.var);
26911 }
26912 }
26913
26914 CHECK_EXCEPTION();
26915 ZEND_VM_NEXT_OPCODE();
26916 }
26917
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26918 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26919 {
26920 USE_OPLINE
26921
26922 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
26923 /* Behave like FETCH_OBJ_W */
26924 zend_free_op free_op1, free_op2;
26925 zval *property;
26926 zval **container;
26927
26928 SAVE_OPLINE();
26929 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26930 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26931
26932 if (1) {
26933 MAKE_REAL_ZVAL_PTR(property);
26934 }
26935 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
26936 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26937 }
26938 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
26939 if (1) {
26940 zval_ptr_dtor(&property);
26941 } else {
26942 zval_dtor(free_op2.var);
26943 }
26944 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
26945 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
26946 }
26947
26948 CHECK_EXCEPTION();
26949 ZEND_VM_NEXT_OPCODE();
26950 } else {
26951 return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26952 }
26953 }
26954
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26955 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26956 {
26957 USE_OPLINE
26958 zend_free_op free_op1, free_op2, free_res;
26959 zval **container;
26960 zval *property;
26961
26962 SAVE_OPLINE();
26963 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26964 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26965
26966 if (IS_UNUSED == IS_CV) {
26967 if (container != &EG(uninitialized_zval_ptr)) {
26968 SEPARATE_ZVAL_IF_NOT_REF(container);
26969 }
26970 }
26971 if (1) {
26972 MAKE_REAL_ZVAL_PTR(property);
26973 }
26974 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
26975 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26976 }
26977 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
26978 if (1) {
26979 zval_ptr_dtor(&property);
26980 } else {
26981 zval_dtor(free_op2.var);
26982 }
26983 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
26984 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
26985 }
26986
26987 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
26988 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
26989 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
26990 }
26991 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
26992 FREE_OP_VAR_PTR(free_res);
26993 CHECK_EXCEPTION();
26994 ZEND_VM_NEXT_OPCODE();
26995 }
26996
ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26997 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26998 {
26999 USE_OPLINE
27000 zend_free_op free_op2;
27001 zval **object_ptr;
27002 zval *property_name;
27003
27004 SAVE_OPLINE();
27005 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27006 property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27007
27008 if (1) {
27009 MAKE_REAL_ZVAL_PTR(property_name);
27010 }
27011 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
27012 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
27013 }
27014 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27015 if (1) {
27016 zval_ptr_dtor(&property_name);
27017 } else {
27018 zval_dtor(free_op2.var);
27019 }
27020
27021 /* assign_obj has two opcodes! */
27022 CHECK_EXCEPTION();
27023 ZEND_VM_INC_OPCODE();
27024 ZEND_VM_NEXT_OPCODE();
27025 }
27026
ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27027 static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27028 {
27029 USE_OPLINE
27030 zend_free_op free_op2;
27031 zval *str = &EX_T(opline->result.var).tmp_var;
27032 zval *var;
27033 zval var_copy;
27034 int use_copy = 0;
27035
27036 SAVE_OPLINE();
27037 var = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27038
27039 if (IS_UNUSED == IS_UNUSED) {
27040 /* Initialize for erealloc in add_string_to_string */
27041 Z_STRVAL_P(str) = NULL;
27042 Z_STRLEN_P(str) = 0;
27043 Z_TYPE_P(str) = IS_STRING;
27044
27045 INIT_PZVAL(str);
27046 }
27047
27048 if (Z_TYPE_P(var) != IS_STRING) {
27049 zend_make_printable_zval(var, &var_copy, &use_copy);
27050
27051 if (use_copy) {
27052 var = &var_copy;
27053 }
27054 }
27055 add_string_to_string(str, str, var);
27056
27057 if (use_copy) {
27058 zval_dtor(var);
27059 }
27060 /* original comment, possibly problematic:
27061 * FREE_OP is missing intentionally here - we're always working on the same temporary variable
27062 * (Zeev): I don't think it's problematic, we only use variables
27063 * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
27064 * string offsets or overloaded objects
27065 */
27066 zval_dtor(free_op2.var);
27067
27068 CHECK_EXCEPTION();
27069 ZEND_VM_NEXT_OPCODE();
27070 }
27071
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27072 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27073 {
27074 USE_OPLINE
27075 zval *function_name;
27076 char *function_name_strval;
27077 int function_name_strlen;
27078 zend_free_op free_op2;
27079 call_slot *call = EX(call_slots) + opline->result.num;
27080
27081 SAVE_OPLINE();
27082
27083 function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27084
27085 if (IS_TMP_VAR != IS_CONST &&
27086 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
27087 if (UNEXPECTED(EG(exception) != NULL)) {
27088 HANDLE_EXCEPTION();
27089 }
27090 zend_error_noreturn(E_ERROR, "Method name must be a string");
27091 }
27092
27093 function_name_strval = Z_STRVAL_P(function_name);
27094 function_name_strlen = Z_STRLEN_P(function_name);
27095
27096 call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
27097
27098 if (EXPECTED(call->object != NULL) &&
27099 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
27100 call->called_scope = Z_OBJCE_P(call->object);
27101
27102 if (IS_TMP_VAR != IS_CONST ||
27103 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
27104 zval *object = call->object;
27105
27106 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
27107 zend_error_noreturn(E_ERROR, "Object does not support method calls");
27108 }
27109
27110 /* First, locate the function. */
27111 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
27112 if (UNEXPECTED(call->fbc == NULL)) {
27113 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
27114 }
27115 if (IS_TMP_VAR == IS_CONST &&
27116 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
27117 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
27118 EXPECTED(call->object == object)) {
27119 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
27120 }
27121 }
27122 } else {
27123 if (UNEXPECTED(EG(exception) != NULL)) {
27124 zval_dtor(free_op2.var);
27125 HANDLE_EXCEPTION();
27126 }
27127 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
27128 }
27129
27130 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
27131 call->object = NULL;
27132 } else {
27133 if (!PZVAL_IS_REF(call->object)) {
27134 Z_ADDREF_P(call->object); /* For $this pointer */
27135 } else {
27136 zval *this_ptr;
27137 ALLOC_ZVAL(this_ptr);
27138 INIT_PZVAL_COPY(this_ptr, call->object);
27139 zval_copy_ctor(this_ptr);
27140 call->object = this_ptr;
27141 }
27142 }
27143
27144 call->num_additional_args = 0;
27145 call->is_ctor_call = 0;
27146 EX(call) = call;
27147
27148 zval_dtor(free_op2.var);
27149
27150 CHECK_EXCEPTION();
27151 ZEND_VM_NEXT_OPCODE();
27152 }
27153
ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27154 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27155 {
27156 USE_OPLINE
27157
27158 array_init(&EX_T(opline->result.var).tmp_var);
27159 if (IS_UNUSED == IS_UNUSED) {
27160 ZEND_VM_NEXT_OPCODE();
27161 #if 0 || IS_UNUSED != IS_UNUSED
27162 } else {
27163 return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27164 #endif
27165 }
27166 }
27167
ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27168 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27169 {
27170 USE_OPLINE
27171 zend_free_op free_op2;
27172 zval **container;
27173 zval *offset;
27174 ulong hval;
27175
27176 SAVE_OPLINE();
27177 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27178 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
27179 SEPARATE_ZVAL_IF_NOT_REF(container);
27180 }
27181 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27182
27183 if (IS_UNUSED != IS_VAR || container) {
27184 switch (Z_TYPE_PP(container)) {
27185 case IS_ARRAY: {
27186 HashTable *ht = Z_ARRVAL_PP(container);
27187
27188 switch (Z_TYPE_P(offset)) {
27189 case IS_DOUBLE:
27190 hval = zend_dval_to_lval(Z_DVAL_P(offset));
27191 zend_hash_index_del(ht, hval);
27192 break;
27193 case IS_RESOURCE:
27194 case IS_BOOL:
27195 case IS_LONG:
27196 hval = Z_LVAL_P(offset);
27197 zend_hash_index_del(ht, hval);
27198 break;
27199 case IS_STRING:
27200 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27201 Z_ADDREF_P(offset);
27202 }
27203 if (IS_TMP_VAR == IS_CONST) {
27204 hval = Z_HASH_P(offset);
27205 } else {
27206 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
27207 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
27208 }
27209 if (ht == &EG(symbol_table)) {
27210 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
27211 } else {
27212 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
27213 }
27214 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27215 zval_ptr_dtor(&offset);
27216 }
27217 break;
27218 num_index_dim:
27219 zend_hash_index_del(ht, hval);
27220 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27221 zval_ptr_dtor(&offset);
27222 }
27223 break;
27224 case IS_NULL:
27225 zend_hash_del(ht, "", sizeof(""));
27226 break;
27227 default:
27228 zend_error(E_WARNING, "Illegal offset type in unset");
27229 break;
27230 }
27231 zval_dtor(free_op2.var);
27232 break;
27233 }
27234 case IS_OBJECT:
27235 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
27236 zend_error_noreturn(E_ERROR, "Cannot use object as array");
27237 }
27238 if (1) {
27239 MAKE_REAL_ZVAL_PTR(offset);
27240 }
27241 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
27242 if (1) {
27243 zval_ptr_dtor(&offset);
27244 } else {
27245 zval_dtor(free_op2.var);
27246 }
27247 break;
27248 case IS_STRING:
27249 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
27250 ZEND_VM_CONTINUE(); /* bailed out before */
27251 default:
27252 zval_dtor(free_op2.var);
27253 break;
27254 }
27255 } else {
27256 zval_dtor(free_op2.var);
27257 }
27258
27259 CHECK_EXCEPTION();
27260 ZEND_VM_NEXT_OPCODE();
27261 }
27262
ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27263 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27264 {
27265 USE_OPLINE
27266 zend_free_op free_op2;
27267 zval **container;
27268 zval *offset;
27269
27270 SAVE_OPLINE();
27271 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27272 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27273
27274 if (IS_UNUSED != IS_VAR || container) {
27275 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
27276 SEPARATE_ZVAL_IF_NOT_REF(container);
27277 }
27278 if (Z_TYPE_PP(container) == IS_OBJECT) {
27279 if (1) {
27280 MAKE_REAL_ZVAL_PTR(offset);
27281 }
27282 if (Z_OBJ_HT_P(*container)->unset_property) {
27283 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27284 } else {
27285 zend_error(E_NOTICE, "Trying to unset property of non-object");
27286 }
27287 if (1) {
27288 zval_ptr_dtor(&offset);
27289 } else {
27290 zval_dtor(free_op2.var);
27291 }
27292 } else {
27293 zval_dtor(free_op2.var);
27294 }
27295 } else {
27296 zval_dtor(free_op2.var);
27297 }
27298
27299 CHECK_EXCEPTION();
27300 ZEND_VM_NEXT_OPCODE();
27301 }
27302
zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)27303 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
27304 {
27305 USE_OPLINE
27306 zend_free_op free_op2;
27307 zval *container;
27308 zval **value = NULL;
27309 int result = 0;
27310 ulong hval;
27311 zval *offset;
27312
27313 SAVE_OPLINE();
27314 container = _get_obj_zval_ptr_unused(TSRMLS_C);
27315 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27316
27317 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
27318 HashTable *ht;
27319 int isset = 0;
27320
27321 ht = Z_ARRVAL_P(container);
27322
27323 switch (Z_TYPE_P(offset)) {
27324 case IS_DOUBLE:
27325 hval = zend_dval_to_lval(Z_DVAL_P(offset));
27326 goto num_index_prop;
27327 case IS_RESOURCE:
27328 case IS_BOOL:
27329 case IS_LONG:
27330 hval = Z_LVAL_P(offset);
27331 num_index_prop:
27332 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
27333 isset = 1;
27334 }
27335 break;
27336 case IS_STRING:
27337 if (IS_TMP_VAR == IS_CONST) {
27338 hval = Z_HASH_P(offset);
27339 } else {
27340 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
27341 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
27342 }
27343 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
27344 isset = 1;
27345 }
27346 break;
27347 case IS_NULL:
27348 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
27349 isset = 1;
27350 }
27351 break;
27352 default:
27353 zend_error(E_WARNING, "Illegal offset type in isset or empty");
27354 break;
27355 }
27356
27357 if (opline->extended_value & ZEND_ISSET) {
27358 if (isset && Z_TYPE_PP(value) == IS_NULL) {
27359 result = 0;
27360 } else {
27361 result = isset;
27362 }
27363 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
27364 if (!isset || !i_zend_is_true(*value)) {
27365 result = 0;
27366 } else {
27367 result = 1;
27368 }
27369 }
27370 zval_dtor(free_op2.var);
27371 } else if (Z_TYPE_P(container) == IS_OBJECT) {
27372 if (1) {
27373 MAKE_REAL_ZVAL_PTR(offset);
27374 }
27375 if (prop_dim) {
27376 if (Z_OBJ_HT_P(container)->has_property) {
27377 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27378 } else {
27379 zend_error(E_NOTICE, "Trying to check property of non-object");
27380 result = 0;
27381 }
27382 } else {
27383 if (Z_OBJ_HT_P(container)->has_dimension) {
27384 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
27385 } else {
27386 zend_error(E_NOTICE, "Trying to check element of non-array");
27387 result = 0;
27388 }
27389 }
27390 if (1) {
27391 zval_ptr_dtor(&offset);
27392 } else {
27393 zval_dtor(free_op2.var);
27394 }
27395 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
27396 zval tmp;
27397
27398 if (Z_TYPE_P(offset) != IS_LONG) {
27399 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
27400 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
27401 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
27402 ZVAL_COPY_VALUE(&tmp, offset);
27403 zval_copy_ctor(&tmp);
27404 convert_to_long(&tmp);
27405 offset = &tmp;
27406 } else {
27407 /* can not be converted to proper offset, return "not set" */
27408 result = 0;
27409 }
27410 }
27411 if (Z_TYPE_P(offset) == IS_LONG) {
27412 if (opline->extended_value & ZEND_ISSET) {
27413 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
27414 result = 1;
27415 }
27416 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
27417 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
27418 result = 1;
27419 }
27420 }
27421 }
27422 zval_dtor(free_op2.var);
27423 } else {
27424 zval_dtor(free_op2.var);
27425 }
27426
27427 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
27428 if (opline->extended_value & ZEND_ISSET) {
27429 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
27430 } else {
27431 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
27432 }
27433
27434 CHECK_EXCEPTION();
27435 ZEND_VM_NEXT_OPCODE();
27436 }
27437
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27438 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27439 {
27440 return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27441 }
27442
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27443 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27444 {
27445 return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27446 }
27447
ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27448 static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27449 {
27450 USE_OPLINE
27451
27452 /* The generator object is stored in return_value_ptr_ptr */
27453 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
27454
27455 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
27456 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
27457 }
27458
27459 /* Destroy the previously yielded value */
27460 if (generator->value) {
27461 zval_ptr_dtor(&generator->value);
27462 }
27463
27464 /* Destroy the previously yielded key */
27465 if (generator->key) {
27466 zval_ptr_dtor(&generator->key);
27467 }
27468
27469 /* Set the new yielded value */
27470 if (IS_UNUSED != IS_UNUSED) {
27471
27472
27473 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
27474 /* Constants and temporary variables aren't yieldable by reference,
27475 * but we still allow them with a notice. */
27476 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
27477 zval *value, *copy;
27478
27479 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
27480
27481 value = NULL;
27482 ALLOC_ZVAL(copy);
27483 INIT_PZVAL_COPY(copy, value);
27484
27485 /* Temporary variables don't need ctor copying */
27486 if (!0) {
27487 zval_copy_ctor(copy);
27488 }
27489
27490 generator->value = copy;
27491 } else {
27492 zval **value_ptr = NULL;
27493
27494 if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
27495 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
27496 }
27497
27498 /* If a function call result is yielded and the function did
27499 * not return by reference we throw a notice. */
27500 if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
27501 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
27502 && EX_T(opline->op1.var).var.fcall_returned_reference)
27503 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
27504 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
27505
27506 Z_ADDREF_PP(value_ptr);
27507 generator->value = *value_ptr;
27508 } else {
27509 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
27510 Z_ADDREF_PP(value_ptr);
27511 generator->value = *value_ptr;
27512 }
27513
27514 }
27515 } else {
27516 zval *value = NULL;
27517
27518 /* Consts, temporary variables and references need copying */
27519 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
27520 || PZVAL_IS_REF(value)
27521 ) {
27522 zval *copy;
27523
27524 ALLOC_ZVAL(copy);
27525 INIT_PZVAL_COPY(copy, value);
27526
27527 /* Temporary variables don't need ctor copying */
27528 if (!0) {
27529 zval_copy_ctor(copy);
27530 }
27531
27532 generator->value = copy;
27533
27534 } else {
27535 if (IS_UNUSED == IS_CV) {
27536 Z_ADDREF_P(value);
27537 }
27538 generator->value = value;
27539 }
27540 }
27541 } else {
27542 /* If no value was specified yield null */
27543 Z_ADDREF(EG(uninitialized_zval));
27544 generator->value = &EG(uninitialized_zval);
27545 }
27546
27547 /* Set the new yielded key */
27548 if (IS_TMP_VAR != IS_UNUSED) {
27549 zend_free_op free_op2;
27550 zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27551
27552 /* Consts, temporary variables and references need copying */
27553 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
27554 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
27555 ) {
27556 zval *copy;
27557
27558 ALLOC_ZVAL(copy);
27559 INIT_PZVAL_COPY(copy, key);
27560
27561 /* Temporary variables don't need ctor copying */
27562 if (!1) {
27563 zval_copy_ctor(copy);
27564 }
27565
27566 generator->key = copy;
27567 } else {
27568 Z_ADDREF_P(key);
27569 generator->key = key;
27570 }
27571
27572 if (Z_TYPE_P(generator->key) == IS_LONG
27573 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
27574 ) {
27575 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
27576 }
27577
27578 } else {
27579 /* If no key was specified we use auto-increment keys */
27580 generator->largest_used_integer_key++;
27581
27582 ALLOC_INIT_ZVAL(generator->key);
27583 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
27584 }
27585
27586 if (RETURN_VALUE_USED(opline)) {
27587 /* If the return value of yield is used set the send
27588 * target and initialize it to NULL */
27589 generator->send_target = &EX_T(opline->result.var).var.ptr;
27590 Z_ADDREF(EG(uninitialized_zval));
27591 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
27592 } else {
27593 generator->send_target = NULL;
27594 }
27595
27596 /* We increment to the next op, so we are at the correct position when the
27597 * generator is resumed. */
27598 ZEND_VM_INC_OPCODE();
27599
27600 /* The GOTO VM uses a local opline variable. We need to set the opline
27601 * variable in execute_data so we don't resume at an old position. */
27602 SAVE_OPLINE();
27603
27604 ZEND_VM_RETURN();
27605 }
27606
ZEND_ASSIGN_POW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27607 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27608 {
27609 return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27610 }
27611
zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)27612 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
27613 {
27614 USE_OPLINE
27615 zend_free_op free_op2, free_op_data1;
27616 zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27617 zval *object;
27618 zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27619 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
27620 int have_get_ptr = 0;
27621
27622 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
27623 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
27624 }
27625
27626 make_real_object(object_ptr TSRMLS_CC);
27627 object = *object_ptr;
27628
27629 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27630 zend_error(E_WARNING, "Attempt to assign property of non-object");
27631 zval_ptr_dtor_nogc(&free_op2.var);
27632 FREE_OP(free_op_data1);
27633
27634 if (RETURN_VALUE_USED(opline)) {
27635 PZVAL_LOCK(&EG(uninitialized_zval));
27636 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
27637 }
27638 } else {
27639 /* here we are sure we are dealing with an object */
27640 if (0) {
27641 MAKE_REAL_ZVAL_PTR(property);
27642 }
27643
27644 /* here property is a string */
27645 if (opline->extended_value == ZEND_ASSIGN_OBJ
27646 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
27647 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27648 if (zptr != NULL) { /* NULL means no success in getting PTR */
27649 have_get_ptr = 1;
27650 if (UNEXPECTED(*zptr == &EG(error_zval))) {
27651 if (RETURN_VALUE_USED(opline)) {
27652 PZVAL_LOCK(&EG(uninitialized_zval));
27653 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
27654 }
27655 } else {
27656 SEPARATE_ZVAL_IF_NOT_REF(zptr);
27657
27658 binary_op(*zptr, *zptr, value TSRMLS_CC);
27659 if (RETURN_VALUE_USED(opline)) {
27660 PZVAL_LOCK(*zptr);
27661 EX_T(opline->result.var).var.ptr = *zptr;
27662 }
27663 }
27664 }
27665 }
27666
27667 if (!have_get_ptr) {
27668 zval *z = NULL;
27669
27670 Z_ADDREF_P(object);
27671 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
27672 if (Z_OBJ_HT_P(object)->read_property) {
27673 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27674 }
27675 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
27676 if (Z_OBJ_HT_P(object)->read_dimension) {
27677 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
27678 }
27679 }
27680 if (z) {
27681 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
27682 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
27683
27684 if (Z_REFCOUNT_P(z) == 0) {
27685 GC_REMOVE_ZVAL_FROM_BUFFER(z);
27686 zval_dtor(z);
27687 FREE_ZVAL(z);
27688 }
27689 z = value;
27690 }
27691 Z_ADDREF_P(z);
27692 SEPARATE_ZVAL_IF_NOT_REF(&z);
27693 binary_op(z, z, value TSRMLS_CC);
27694 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
27695 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27696 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
27697 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
27698 }
27699 if (RETURN_VALUE_USED(opline)) {
27700 PZVAL_LOCK(z);
27701 EX_T(opline->result.var).var.ptr = z;
27702 }
27703 zval_ptr_dtor(&z);
27704 } else {
27705 zend_error(E_WARNING, "Attempt to assign property of non-object");
27706 if (RETURN_VALUE_USED(opline)) {
27707 PZVAL_LOCK(&EG(uninitialized_zval));
27708 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
27709 }
27710 }
27711 zval_ptr_dtor(&object);
27712 }
27713
27714 if (0) {
27715 zval_ptr_dtor(&property);
27716 } else {
27717 zval_ptr_dtor_nogc(&free_op2.var);
27718 }
27719 FREE_OP(free_op_data1);
27720 }
27721
27722 /* assign_obj has two opcodes! */
27723 CHECK_EXCEPTION();
27724 ZEND_VM_INC_OPCODE();
27725 ZEND_VM_NEXT_OPCODE();
27726 }
27727
zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)27728 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
27729 {
27730 USE_OPLINE
27731 zend_free_op free_op2, free_op_data2, free_op_data1;
27732 zval **var_ptr;
27733 zval *value;
27734
27735 SAVE_OPLINE();
27736 switch (opline->extended_value) {
27737 case ZEND_ASSIGN_OBJ:
27738 return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27739 break;
27740 case ZEND_ASSIGN_DIM: {
27741 zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27742
27743 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
27744 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
27745 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
27746 if (IS_UNUSED == IS_VAR && !0) {
27747 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
27748 }
27749 return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27750 } else {
27751 zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27752
27753 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC);
27754 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
27755 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
27756 }
27757 }
27758 break;
27759 default:
27760 value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27761 var_ptr = NULL;
27762 /* do nothing */
27763 break;
27764 }
27765
27766 if (UNEXPECTED(var_ptr == NULL)) {
27767 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
27768 }
27769
27770 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
27771 if (RETURN_VALUE_USED(opline)) {
27772 PZVAL_LOCK(&EG(uninitialized_zval));
27773 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
27774 }
27775 zval_ptr_dtor_nogc(&free_op2.var);
27776
27777 CHECK_EXCEPTION();
27778 if (opline->extended_value == ZEND_ASSIGN_DIM) {
27779 ZEND_VM_INC_OPCODE();
27780 }
27781 ZEND_VM_NEXT_OPCODE();
27782 }
27783
27784 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
27785
27786 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
27787 && Z_OBJ_HANDLER_PP(var_ptr, get)
27788 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
27789 /* proxy object */
27790 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
27791 Z_ADDREF_P(objval);
27792 binary_op(objval, objval, value TSRMLS_CC);
27793 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
27794 zval_ptr_dtor(&objval);
27795 } else {
27796 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
27797 }
27798
27799 if (RETURN_VALUE_USED(opline)) {
27800 PZVAL_LOCK(*var_ptr);
27801 EX_T(opline->result.var).var.ptr = *var_ptr;
27802 }
27803 zval_ptr_dtor_nogc(&free_op2.var);
27804
27805 if (opline->extended_value == ZEND_ASSIGN_DIM) {
27806 FREE_OP(free_op_data1);
27807 FREE_OP_VAR_PTR(free_op_data2);
27808
27809 CHECK_EXCEPTION();
27810 ZEND_VM_INC_OPCODE();
27811 } else {
27812
27813 CHECK_EXCEPTION();
27814 }
27815 ZEND_VM_NEXT_OPCODE();
27816 }
27817
ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27818 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27819 {
27820 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27821 }
27822
ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27823 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27824 {
27825 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27826 }
27827
ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27828 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27829 {
27830 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27831 }
27832
ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27833 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27834 {
27835 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27836 }
27837
ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27838 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27839 {
27840 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27841 }
27842
ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27843 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27844 {
27845 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27846 }
27847
ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27848 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27849 {
27850 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27851 }
27852
ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27853 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27854 {
27855 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27856 }
27857
ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27858 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27859 {
27860 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27861 }
27862
ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27863 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27864 {
27865 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27866 }
27867
ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27868 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27869 {
27870 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27871 }
27872
zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)27873 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
27874 {
27875 USE_OPLINE
27876 zend_free_op free_op2;
27877 zval **object_ptr;
27878 zval *object;
27879 zval *property;
27880 zval **retval;
27881 int have_get_ptr = 0;
27882
27883 SAVE_OPLINE();
27884 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27885 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27886 retval = &EX_T(opline->result.var).var.ptr;
27887
27888 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
27889 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
27890 }
27891
27892 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
27893 object = *object_ptr;
27894
27895 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27896 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
27897 zval_ptr_dtor_nogc(&free_op2.var);
27898 if (RETURN_VALUE_USED(opline)) {
27899 PZVAL_LOCK(&EG(uninitialized_zval));
27900 *retval = &EG(uninitialized_zval);
27901 }
27902
27903 CHECK_EXCEPTION();
27904 ZEND_VM_NEXT_OPCODE();
27905 }
27906
27907 /* here we are sure we are dealing with an object */
27908
27909 if (0) {
27910 MAKE_REAL_ZVAL_PTR(property);
27911 }
27912
27913 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
27914 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27915 if (zptr != NULL) { /* NULL means no success in getting PTR */
27916 have_get_ptr = 1;
27917 if (UNEXPECTED(*zptr == &EG(error_zval))) {
27918 if (RETURN_VALUE_USED(opline)) {
27919 PZVAL_LOCK(&EG(uninitialized_zval));
27920 *retval = &EG(uninitialized_zval);
27921 }
27922 } else {
27923 SEPARATE_ZVAL_IF_NOT_REF(zptr);
27924
27925 incdec_op(*zptr);
27926 if (RETURN_VALUE_USED(opline)) {
27927 *retval = *zptr;
27928 PZVAL_LOCK(*retval);
27929 }
27930 }
27931 }
27932 }
27933
27934 if (!have_get_ptr) {
27935 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
27936 zval *z;
27937
27938 Z_ADDREF_P(object);
27939 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27940
27941 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
27942 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
27943
27944 if (Z_REFCOUNT_P(z) == 0) {
27945 GC_REMOVE_ZVAL_FROM_BUFFER(z);
27946 zval_dtor(z);
27947 FREE_ZVAL(z);
27948 }
27949 z = value;
27950 }
27951 Z_ADDREF_P(z);
27952 SEPARATE_ZVAL_IF_NOT_REF(&z);
27953 incdec_op(z);
27954 *retval = z;
27955 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27956 zval_ptr_dtor(&object);
27957 SELECTIVE_PZVAL_LOCK(*retval, opline);
27958 zval_ptr_dtor(&z);
27959 } else {
27960 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
27961 if (RETURN_VALUE_USED(opline)) {
27962 PZVAL_LOCK(&EG(uninitialized_zval));
27963 *retval = &EG(uninitialized_zval);
27964 }
27965 }
27966 }
27967
27968 if (0) {
27969 zval_ptr_dtor(&property);
27970 } else {
27971 zval_ptr_dtor_nogc(&free_op2.var);
27972 }
27973
27974 CHECK_EXCEPTION();
27975 ZEND_VM_NEXT_OPCODE();
27976 }
27977
ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27978 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27979 {
27980 return zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27981 }
27982
ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27983 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27984 {
27985 return zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27986 }
27987
zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)27988 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
27989 {
27990 USE_OPLINE
27991 zend_free_op free_op2;
27992 zval **object_ptr;
27993 zval *object;
27994 zval *property;
27995 zval *retval;
27996 int have_get_ptr = 0;
27997
27998 SAVE_OPLINE();
27999 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28000 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28001 retval = &EX_T(opline->result.var).tmp_var;
28002
28003 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
28004 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
28005 }
28006
28007 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
28008 object = *object_ptr;
28009
28010 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
28011 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
28012 zval_ptr_dtor_nogc(&free_op2.var);
28013 ZVAL_NULL(retval);
28014
28015 CHECK_EXCEPTION();
28016 ZEND_VM_NEXT_OPCODE();
28017 }
28018
28019 /* here we are sure we are dealing with an object */
28020
28021 if (0) {
28022 MAKE_REAL_ZVAL_PTR(property);
28023 }
28024
28025 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
28026 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28027 if (zptr != NULL) { /* NULL means no success in getting PTR */
28028 have_get_ptr = 1;
28029 if (UNEXPECTED(*zptr == &EG(error_zval))) {
28030 ZVAL_NULL(retval);
28031 } else {
28032 SEPARATE_ZVAL_IF_NOT_REF(zptr);
28033
28034 ZVAL_COPY_VALUE(retval, *zptr);
28035 zendi_zval_copy_ctor(*retval);
28036
28037 incdec_op(*zptr);
28038 }
28039 }
28040 }
28041
28042 if (!have_get_ptr) {
28043 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
28044 zval *z, *z_copy;
28045
28046 Z_ADDREF_P(object);
28047 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28048 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
28049 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
28050
28051 if (Z_REFCOUNT_P(z) == 0) {
28052 GC_REMOVE_ZVAL_FROM_BUFFER(z);
28053 zval_dtor(z);
28054 FREE_ZVAL(z);
28055 }
28056 z = value;
28057 }
28058 ZVAL_COPY_VALUE(retval, z);
28059 zendi_zval_copy_ctor(*retval);
28060 ALLOC_ZVAL(z_copy);
28061 INIT_PZVAL_COPY(z_copy, z);
28062 zendi_zval_copy_ctor(*z_copy);
28063 incdec_op(z_copy);
28064 Z_ADDREF_P(z);
28065 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28066 zval_ptr_dtor(&object);
28067 zval_ptr_dtor(&z_copy);
28068 zval_ptr_dtor(&z);
28069 } else {
28070 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
28071 ZVAL_NULL(retval);
28072 }
28073 }
28074
28075 if (0) {
28076 zval_ptr_dtor(&property);
28077 } else {
28078 zval_ptr_dtor_nogc(&free_op2.var);
28079 }
28080
28081 CHECK_EXCEPTION();
28082 ZEND_VM_NEXT_OPCODE();
28083 }
28084
ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28085 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28086 {
28087 return zend_post_incdec_property_helper_SPEC_UNUSED_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28088 }
28089
ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28090 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28091 {
28092 return zend_post_incdec_property_helper_SPEC_UNUSED_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28093 }
28094
zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS)28095 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS)
28096 {
28097 USE_OPLINE
28098
28099 zval *container;
28100 zend_free_op free_op2;
28101 zval *offset;
28102
28103 SAVE_OPLINE();
28104 container = _get_obj_zval_ptr_unused(TSRMLS_C);
28105 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28106
28107 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
28108 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
28109 zend_error(E_NOTICE, "Trying to get property of non-object");
28110 PZVAL_LOCK(&EG(uninitialized_zval));
28111 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
28112 zval_ptr_dtor_nogc(&free_op2.var);
28113 } else {
28114 zval *retval;
28115
28116 if (0) {
28117 MAKE_REAL_ZVAL_PTR(offset);
28118 }
28119
28120 /* here we are sure we are dealing with an object */
28121 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28122
28123 PZVAL_LOCK(retval);
28124 EX_T(opline->result.var).var.ptr = retval;
28125
28126 if (0) {
28127 zval_ptr_dtor(&offset);
28128 } else {
28129 zval_ptr_dtor_nogc(&free_op2.var);
28130 }
28131 }
28132
28133 CHECK_EXCEPTION();
28134 ZEND_VM_NEXT_OPCODE();
28135 }
28136
ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28137 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28138 {
28139 return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28140 }
28141
ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28142 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28143 {
28144 USE_OPLINE
28145 zend_free_op free_op1, free_op2;
28146 zval *property;
28147 zval **container;
28148
28149 SAVE_OPLINE();
28150 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28151
28152 if (0) {
28153 MAKE_REAL_ZVAL_PTR(property);
28154 }
28155 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28156 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
28157 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
28158 }
28159
28160 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
28161 if (0) {
28162 zval_ptr_dtor(&property);
28163 } else {
28164 zval_ptr_dtor_nogc(&free_op2.var);
28165 }
28166 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
28167 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
28168 }
28169
28170 /* We are going to assign the result by reference */
28171 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
28172 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
28173
28174 Z_DELREF_PP(retval_ptr);
28175 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
28176 Z_ADDREF_PP(retval_ptr);
28177 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
28178 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
28179 }
28180
28181 CHECK_EXCEPTION();
28182 ZEND_VM_NEXT_OPCODE();
28183 }
28184
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28185 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28186 {
28187 USE_OPLINE
28188 zend_free_op free_op1, free_op2;
28189 zval *property;
28190 zval **container;
28191
28192 SAVE_OPLINE();
28193 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28194 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28195
28196 if (0) {
28197 MAKE_REAL_ZVAL_PTR(property);
28198 }
28199 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
28200 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
28201 }
28202 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
28203 if (0) {
28204 zval_ptr_dtor(&property);
28205 } else {
28206 zval_ptr_dtor_nogc(&free_op2.var);
28207 }
28208 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
28209 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
28210 }
28211
28212 CHECK_EXCEPTION();
28213 ZEND_VM_NEXT_OPCODE();
28214 }
28215
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28216 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28217 {
28218 USE_OPLINE
28219
28220 zval *container;
28221 zend_free_op free_op2;
28222 zval *offset;
28223
28224 SAVE_OPLINE();
28225 container = _get_obj_zval_ptr_unused(TSRMLS_C);
28226 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28227
28228 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
28229 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
28230 PZVAL_LOCK(&EG(uninitialized_zval));
28231 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
28232 zval_ptr_dtor_nogc(&free_op2.var);
28233 } else {
28234 zval *retval;
28235
28236 if (0) {
28237 MAKE_REAL_ZVAL_PTR(offset);
28238 }
28239
28240 /* here we are sure we are dealing with an object */
28241 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28242
28243 PZVAL_LOCK(retval);
28244 EX_T(opline->result.var).var.ptr = retval;
28245
28246 if (0) {
28247 zval_ptr_dtor(&offset);
28248 } else {
28249 zval_ptr_dtor_nogc(&free_op2.var);
28250 }
28251 }
28252
28253 CHECK_EXCEPTION();
28254 ZEND_VM_NEXT_OPCODE();
28255 }
28256
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28257 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28258 {
28259 USE_OPLINE
28260
28261 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
28262 /* Behave like FETCH_OBJ_W */
28263 zend_free_op free_op1, free_op2;
28264 zval *property;
28265 zval **container;
28266
28267 SAVE_OPLINE();
28268 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28269 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28270
28271 if (0) {
28272 MAKE_REAL_ZVAL_PTR(property);
28273 }
28274 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
28275 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
28276 }
28277 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
28278 if (0) {
28279 zval_ptr_dtor(&property);
28280 } else {
28281 zval_ptr_dtor_nogc(&free_op2.var);
28282 }
28283 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
28284 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
28285 }
28286
28287 CHECK_EXCEPTION();
28288 ZEND_VM_NEXT_OPCODE();
28289 } else {
28290 return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28291 }
28292 }
28293
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28294 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28295 {
28296 USE_OPLINE
28297 zend_free_op free_op1, free_op2, free_res;
28298 zval **container;
28299 zval *property;
28300
28301 SAVE_OPLINE();
28302 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28303 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28304
28305 if (IS_UNUSED == IS_CV) {
28306 if (container != &EG(uninitialized_zval_ptr)) {
28307 SEPARATE_ZVAL_IF_NOT_REF(container);
28308 }
28309 }
28310 if (0) {
28311 MAKE_REAL_ZVAL_PTR(property);
28312 }
28313 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
28314 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
28315 }
28316 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
28317 if (0) {
28318 zval_ptr_dtor(&property);
28319 } else {
28320 zval_ptr_dtor_nogc(&free_op2.var);
28321 }
28322 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
28323 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
28324 }
28325
28326 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
28327 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
28328 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
28329 }
28330 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
28331 FREE_OP_VAR_PTR(free_res);
28332 CHECK_EXCEPTION();
28333 ZEND_VM_NEXT_OPCODE();
28334 }
28335
ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28336 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28337 {
28338 USE_OPLINE
28339 zend_free_op free_op2;
28340 zval **object_ptr;
28341 zval *property_name;
28342
28343 SAVE_OPLINE();
28344 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28345 property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28346
28347 if (0) {
28348 MAKE_REAL_ZVAL_PTR(property_name);
28349 }
28350 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
28351 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28352 }
28353 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28354 if (0) {
28355 zval_ptr_dtor(&property_name);
28356 } else {
28357 zval_ptr_dtor_nogc(&free_op2.var);
28358 }
28359
28360 /* assign_obj has two opcodes! */
28361 CHECK_EXCEPTION();
28362 ZEND_VM_INC_OPCODE();
28363 ZEND_VM_NEXT_OPCODE();
28364 }
28365
ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28366 static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28367 {
28368 USE_OPLINE
28369 zend_free_op free_op2;
28370 zval *str = &EX_T(opline->result.var).tmp_var;
28371 zval *var;
28372 zval var_copy;
28373 int use_copy = 0;
28374
28375 SAVE_OPLINE();
28376 var = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28377
28378 if (IS_UNUSED == IS_UNUSED) {
28379 /* Initialize for erealloc in add_string_to_string */
28380 Z_STRVAL_P(str) = NULL;
28381 Z_STRLEN_P(str) = 0;
28382 Z_TYPE_P(str) = IS_STRING;
28383
28384 INIT_PZVAL(str);
28385 }
28386
28387 if (Z_TYPE_P(var) != IS_STRING) {
28388 zend_make_printable_zval(var, &var_copy, &use_copy);
28389
28390 if (use_copy) {
28391 var = &var_copy;
28392 }
28393 }
28394 add_string_to_string(str, str, var);
28395
28396 if (use_copy) {
28397 zval_dtor(var);
28398 }
28399 /* original comment, possibly problematic:
28400 * FREE_OP is missing intentionally here - we're always working on the same temporary variable
28401 * (Zeev): I don't think it's problematic, we only use variables
28402 * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
28403 * string offsets or overloaded objects
28404 */
28405 zval_ptr_dtor_nogc(&free_op2.var);
28406
28407 CHECK_EXCEPTION();
28408 ZEND_VM_NEXT_OPCODE();
28409 }
28410
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28411 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28412 {
28413 USE_OPLINE
28414 zval *function_name;
28415 char *function_name_strval;
28416 int function_name_strlen;
28417 zend_free_op free_op2;
28418 call_slot *call = EX(call_slots) + opline->result.num;
28419
28420 SAVE_OPLINE();
28421
28422 function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28423
28424 if (IS_VAR != IS_CONST &&
28425 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
28426 if (UNEXPECTED(EG(exception) != NULL)) {
28427 HANDLE_EXCEPTION();
28428 }
28429 zend_error_noreturn(E_ERROR, "Method name must be a string");
28430 }
28431
28432 function_name_strval = Z_STRVAL_P(function_name);
28433 function_name_strlen = Z_STRLEN_P(function_name);
28434
28435 call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
28436
28437 if (EXPECTED(call->object != NULL) &&
28438 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
28439 call->called_scope = Z_OBJCE_P(call->object);
28440
28441 if (IS_VAR != IS_CONST ||
28442 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
28443 zval *object = call->object;
28444
28445 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
28446 zend_error_noreturn(E_ERROR, "Object does not support method calls");
28447 }
28448
28449 /* First, locate the function. */
28450 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
28451 if (UNEXPECTED(call->fbc == NULL)) {
28452 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
28453 }
28454 if (IS_VAR == IS_CONST &&
28455 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
28456 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
28457 EXPECTED(call->object == object)) {
28458 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
28459 }
28460 }
28461 } else {
28462 if (UNEXPECTED(EG(exception) != NULL)) {
28463 zval_ptr_dtor_nogc(&free_op2.var);
28464 HANDLE_EXCEPTION();
28465 }
28466 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
28467 }
28468
28469 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
28470 call->object = NULL;
28471 } else {
28472 if (!PZVAL_IS_REF(call->object)) {
28473 Z_ADDREF_P(call->object); /* For $this pointer */
28474 } else {
28475 zval *this_ptr;
28476 ALLOC_ZVAL(this_ptr);
28477 INIT_PZVAL_COPY(this_ptr, call->object);
28478 zval_copy_ctor(this_ptr);
28479 call->object = this_ptr;
28480 }
28481 }
28482
28483 call->num_additional_args = 0;
28484 call->is_ctor_call = 0;
28485 EX(call) = call;
28486
28487 zval_ptr_dtor_nogc(&free_op2.var);
28488
28489 CHECK_EXCEPTION();
28490 ZEND_VM_NEXT_OPCODE();
28491 }
28492
ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28493 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28494 {
28495 USE_OPLINE
28496
28497 array_init(&EX_T(opline->result.var).tmp_var);
28498 if (IS_UNUSED == IS_UNUSED) {
28499 ZEND_VM_NEXT_OPCODE();
28500 #if 0 || IS_UNUSED != IS_UNUSED
28501 } else {
28502 return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28503 #endif
28504 }
28505 }
28506
ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28507 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28508 {
28509 USE_OPLINE
28510 zend_free_op free_op2;
28511 zval **container;
28512 zval *offset;
28513 ulong hval;
28514
28515 SAVE_OPLINE();
28516 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28517 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
28518 SEPARATE_ZVAL_IF_NOT_REF(container);
28519 }
28520 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28521
28522 if (IS_UNUSED != IS_VAR || container) {
28523 switch (Z_TYPE_PP(container)) {
28524 case IS_ARRAY: {
28525 HashTable *ht = Z_ARRVAL_PP(container);
28526
28527 switch (Z_TYPE_P(offset)) {
28528 case IS_DOUBLE:
28529 hval = zend_dval_to_lval(Z_DVAL_P(offset));
28530 zend_hash_index_del(ht, hval);
28531 break;
28532 case IS_RESOURCE:
28533 case IS_BOOL:
28534 case IS_LONG:
28535 hval = Z_LVAL_P(offset);
28536 zend_hash_index_del(ht, hval);
28537 break;
28538 case IS_STRING:
28539 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
28540 Z_ADDREF_P(offset);
28541 }
28542 if (IS_VAR == IS_CONST) {
28543 hval = Z_HASH_P(offset);
28544 } else {
28545 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
28546 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
28547 }
28548 if (ht == &EG(symbol_table)) {
28549 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
28550 } else {
28551 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
28552 }
28553 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
28554 zval_ptr_dtor(&offset);
28555 }
28556 break;
28557 num_index_dim:
28558 zend_hash_index_del(ht, hval);
28559 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
28560 zval_ptr_dtor(&offset);
28561 }
28562 break;
28563 case IS_NULL:
28564 zend_hash_del(ht, "", sizeof(""));
28565 break;
28566 default:
28567 zend_error(E_WARNING, "Illegal offset type in unset");
28568 break;
28569 }
28570 zval_ptr_dtor_nogc(&free_op2.var);
28571 break;
28572 }
28573 case IS_OBJECT:
28574 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
28575 zend_error_noreturn(E_ERROR, "Cannot use object as array");
28576 }
28577 if (0) {
28578 MAKE_REAL_ZVAL_PTR(offset);
28579 }
28580 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
28581 if (0) {
28582 zval_ptr_dtor(&offset);
28583 } else {
28584 zval_ptr_dtor_nogc(&free_op2.var);
28585 }
28586 break;
28587 case IS_STRING:
28588 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
28589 ZEND_VM_CONTINUE(); /* bailed out before */
28590 default:
28591 zval_ptr_dtor_nogc(&free_op2.var);
28592 break;
28593 }
28594 } else {
28595 zval_ptr_dtor_nogc(&free_op2.var);
28596 }
28597
28598 CHECK_EXCEPTION();
28599 ZEND_VM_NEXT_OPCODE();
28600 }
28601
ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28602 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28603 {
28604 USE_OPLINE
28605 zend_free_op free_op2;
28606 zval **container;
28607 zval *offset;
28608
28609 SAVE_OPLINE();
28610 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28611 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28612
28613 if (IS_UNUSED != IS_VAR || container) {
28614 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
28615 SEPARATE_ZVAL_IF_NOT_REF(container);
28616 }
28617 if (Z_TYPE_PP(container) == IS_OBJECT) {
28618 if (0) {
28619 MAKE_REAL_ZVAL_PTR(offset);
28620 }
28621 if (Z_OBJ_HT_P(*container)->unset_property) {
28622 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28623 } else {
28624 zend_error(E_NOTICE, "Trying to unset property of non-object");
28625 }
28626 if (0) {
28627 zval_ptr_dtor(&offset);
28628 } else {
28629 zval_ptr_dtor_nogc(&free_op2.var);
28630 }
28631 } else {
28632 zval_ptr_dtor_nogc(&free_op2.var);
28633 }
28634 } else {
28635 zval_ptr_dtor_nogc(&free_op2.var);
28636 }
28637
28638 CHECK_EXCEPTION();
28639 ZEND_VM_NEXT_OPCODE();
28640 }
28641
zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)28642 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
28643 {
28644 USE_OPLINE
28645 zend_free_op free_op2;
28646 zval *container;
28647 zval **value = NULL;
28648 int result = 0;
28649 ulong hval;
28650 zval *offset;
28651
28652 SAVE_OPLINE();
28653 container = _get_obj_zval_ptr_unused(TSRMLS_C);
28654 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28655
28656 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
28657 HashTable *ht;
28658 int isset = 0;
28659
28660 ht = Z_ARRVAL_P(container);
28661
28662 switch (Z_TYPE_P(offset)) {
28663 case IS_DOUBLE:
28664 hval = zend_dval_to_lval(Z_DVAL_P(offset));
28665 goto num_index_prop;
28666 case IS_RESOURCE:
28667 case IS_BOOL:
28668 case IS_LONG:
28669 hval = Z_LVAL_P(offset);
28670 num_index_prop:
28671 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
28672 isset = 1;
28673 }
28674 break;
28675 case IS_STRING:
28676 if (IS_VAR == IS_CONST) {
28677 hval = Z_HASH_P(offset);
28678 } else {
28679 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
28680 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
28681 }
28682 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
28683 isset = 1;
28684 }
28685 break;
28686 case IS_NULL:
28687 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
28688 isset = 1;
28689 }
28690 break;
28691 default:
28692 zend_error(E_WARNING, "Illegal offset type in isset or empty");
28693 break;
28694 }
28695
28696 if (opline->extended_value & ZEND_ISSET) {
28697 if (isset && Z_TYPE_PP(value) == IS_NULL) {
28698 result = 0;
28699 } else {
28700 result = isset;
28701 }
28702 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
28703 if (!isset || !i_zend_is_true(*value)) {
28704 result = 0;
28705 } else {
28706 result = 1;
28707 }
28708 }
28709 zval_ptr_dtor_nogc(&free_op2.var);
28710 } else if (Z_TYPE_P(container) == IS_OBJECT) {
28711 if (0) {
28712 MAKE_REAL_ZVAL_PTR(offset);
28713 }
28714 if (prop_dim) {
28715 if (Z_OBJ_HT_P(container)->has_property) {
28716 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28717 } else {
28718 zend_error(E_NOTICE, "Trying to check property of non-object");
28719 result = 0;
28720 }
28721 } else {
28722 if (Z_OBJ_HT_P(container)->has_dimension) {
28723 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
28724 } else {
28725 zend_error(E_NOTICE, "Trying to check element of non-array");
28726 result = 0;
28727 }
28728 }
28729 if (0) {
28730 zval_ptr_dtor(&offset);
28731 } else {
28732 zval_ptr_dtor_nogc(&free_op2.var);
28733 }
28734 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
28735 zval tmp;
28736
28737 if (Z_TYPE_P(offset) != IS_LONG) {
28738 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
28739 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
28740 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
28741 ZVAL_COPY_VALUE(&tmp, offset);
28742 zval_copy_ctor(&tmp);
28743 convert_to_long(&tmp);
28744 offset = &tmp;
28745 } else {
28746 /* can not be converted to proper offset, return "not set" */
28747 result = 0;
28748 }
28749 }
28750 if (Z_TYPE_P(offset) == IS_LONG) {
28751 if (opline->extended_value & ZEND_ISSET) {
28752 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
28753 result = 1;
28754 }
28755 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
28756 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
28757 result = 1;
28758 }
28759 }
28760 }
28761 zval_ptr_dtor_nogc(&free_op2.var);
28762 } else {
28763 zval_ptr_dtor_nogc(&free_op2.var);
28764 }
28765
28766 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
28767 if (opline->extended_value & ZEND_ISSET) {
28768 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
28769 } else {
28770 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
28771 }
28772
28773 CHECK_EXCEPTION();
28774 ZEND_VM_NEXT_OPCODE();
28775 }
28776
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28777 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28778 {
28779 return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28780 }
28781
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28782 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28783 {
28784 return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28785 }
28786
ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28787 static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28788 {
28789 USE_OPLINE
28790
28791 /* The generator object is stored in return_value_ptr_ptr */
28792 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
28793
28794 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
28795 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
28796 }
28797
28798 /* Destroy the previously yielded value */
28799 if (generator->value) {
28800 zval_ptr_dtor(&generator->value);
28801 }
28802
28803 /* Destroy the previously yielded key */
28804 if (generator->key) {
28805 zval_ptr_dtor(&generator->key);
28806 }
28807
28808 /* Set the new yielded value */
28809 if (IS_UNUSED != IS_UNUSED) {
28810
28811
28812 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
28813 /* Constants and temporary variables aren't yieldable by reference,
28814 * but we still allow them with a notice. */
28815 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
28816 zval *value, *copy;
28817
28818 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28819
28820 value = NULL;
28821 ALLOC_ZVAL(copy);
28822 INIT_PZVAL_COPY(copy, value);
28823
28824 /* Temporary variables don't need ctor copying */
28825 if (!0) {
28826 zval_copy_ctor(copy);
28827 }
28828
28829 generator->value = copy;
28830 } else {
28831 zval **value_ptr = NULL;
28832
28833 if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
28834 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
28835 }
28836
28837 /* If a function call result is yielded and the function did
28838 * not return by reference we throw a notice. */
28839 if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
28840 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
28841 && EX_T(opline->op1.var).var.fcall_returned_reference)
28842 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
28843 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28844
28845 Z_ADDREF_PP(value_ptr);
28846 generator->value = *value_ptr;
28847 } else {
28848 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
28849 Z_ADDREF_PP(value_ptr);
28850 generator->value = *value_ptr;
28851 }
28852
28853 }
28854 } else {
28855 zval *value = NULL;
28856
28857 /* Consts, temporary variables and references need copying */
28858 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
28859 || PZVAL_IS_REF(value)
28860 ) {
28861 zval *copy;
28862
28863 ALLOC_ZVAL(copy);
28864 INIT_PZVAL_COPY(copy, value);
28865
28866 /* Temporary variables don't need ctor copying */
28867 if (!0) {
28868 zval_copy_ctor(copy);
28869 }
28870
28871 generator->value = copy;
28872
28873 } else {
28874 if (IS_UNUSED == IS_CV) {
28875 Z_ADDREF_P(value);
28876 }
28877 generator->value = value;
28878 }
28879 }
28880 } else {
28881 /* If no value was specified yield null */
28882 Z_ADDREF(EG(uninitialized_zval));
28883 generator->value = &EG(uninitialized_zval);
28884 }
28885
28886 /* Set the new yielded key */
28887 if (IS_VAR != IS_UNUSED) {
28888 zend_free_op free_op2;
28889 zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28890
28891 /* Consts, temporary variables and references need copying */
28892 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
28893 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
28894 ) {
28895 zval *copy;
28896
28897 ALLOC_ZVAL(copy);
28898 INIT_PZVAL_COPY(copy, key);
28899
28900 /* Temporary variables don't need ctor copying */
28901 if (!0) {
28902 zval_copy_ctor(copy);
28903 }
28904
28905 generator->key = copy;
28906 } else {
28907 Z_ADDREF_P(key);
28908 generator->key = key;
28909 }
28910
28911 if (Z_TYPE_P(generator->key) == IS_LONG
28912 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
28913 ) {
28914 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
28915 }
28916
28917 zval_ptr_dtor_nogc(&free_op2.var);
28918 } else {
28919 /* If no key was specified we use auto-increment keys */
28920 generator->largest_used_integer_key++;
28921
28922 ALLOC_INIT_ZVAL(generator->key);
28923 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
28924 }
28925
28926 if (RETURN_VALUE_USED(opline)) {
28927 /* If the return value of yield is used set the send
28928 * target and initialize it to NULL */
28929 generator->send_target = &EX_T(opline->result.var).var.ptr;
28930 Z_ADDREF(EG(uninitialized_zval));
28931 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
28932 } else {
28933 generator->send_target = NULL;
28934 }
28935
28936 /* We increment to the next op, so we are at the correct position when the
28937 * generator is resumed. */
28938 ZEND_VM_INC_OPCODE();
28939
28940 /* The GOTO VM uses a local opline variable. We need to set the opline
28941 * variable in execute_data so we don't resume at an old position. */
28942 SAVE_OPLINE();
28943
28944 ZEND_VM_RETURN();
28945 }
28946
ZEND_ASSIGN_POW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28947 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28948 {
28949 return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28950 }
28951
zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)28952 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
28953 {
28954 USE_OPLINE
28955 zend_free_op free_op_data1;
28956 zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28957 zval *object;
28958 zval *property = NULL;
28959 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
28960 int have_get_ptr = 0;
28961
28962 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
28963 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
28964 }
28965
28966 make_real_object(object_ptr TSRMLS_CC);
28967 object = *object_ptr;
28968
28969 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
28970 zend_error(E_WARNING, "Attempt to assign property of non-object");
28971
28972 FREE_OP(free_op_data1);
28973
28974 if (RETURN_VALUE_USED(opline)) {
28975 PZVAL_LOCK(&EG(uninitialized_zval));
28976 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
28977 }
28978 } else {
28979 /* here we are sure we are dealing with an object */
28980 if (0) {
28981 MAKE_REAL_ZVAL_PTR(property);
28982 }
28983
28984 /* here property is a string */
28985 if (opline->extended_value == ZEND_ASSIGN_OBJ
28986 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
28987 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28988 if (zptr != NULL) { /* NULL means no success in getting PTR */
28989 have_get_ptr = 1;
28990 if (UNEXPECTED(*zptr == &EG(error_zval))) {
28991 if (RETURN_VALUE_USED(opline)) {
28992 PZVAL_LOCK(&EG(uninitialized_zval));
28993 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
28994 }
28995 } else {
28996 SEPARATE_ZVAL_IF_NOT_REF(zptr);
28997
28998 binary_op(*zptr, *zptr, value TSRMLS_CC);
28999 if (RETURN_VALUE_USED(opline)) {
29000 PZVAL_LOCK(*zptr);
29001 EX_T(opline->result.var).var.ptr = *zptr;
29002 }
29003 }
29004 }
29005 }
29006
29007 if (!have_get_ptr) {
29008 zval *z = NULL;
29009
29010 Z_ADDREF_P(object);
29011 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
29012 if (Z_OBJ_HT_P(object)->read_property) {
29013 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29014 }
29015 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
29016 if (Z_OBJ_HT_P(object)->read_dimension) {
29017 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
29018 }
29019 }
29020 if (z) {
29021 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
29022 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
29023
29024 if (Z_REFCOUNT_P(z) == 0) {
29025 GC_REMOVE_ZVAL_FROM_BUFFER(z);
29026 zval_dtor(z);
29027 FREE_ZVAL(z);
29028 }
29029 z = value;
29030 }
29031 Z_ADDREF_P(z);
29032 SEPARATE_ZVAL_IF_NOT_REF(&z);
29033 binary_op(z, z, value TSRMLS_CC);
29034 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
29035 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29036 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
29037 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
29038 }
29039 if (RETURN_VALUE_USED(opline)) {
29040 PZVAL_LOCK(z);
29041 EX_T(opline->result.var).var.ptr = z;
29042 }
29043 zval_ptr_dtor(&z);
29044 } else {
29045 zend_error(E_WARNING, "Attempt to assign property of non-object");
29046 if (RETURN_VALUE_USED(opline)) {
29047 PZVAL_LOCK(&EG(uninitialized_zval));
29048 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29049 }
29050 }
29051 zval_ptr_dtor(&object);
29052 }
29053
29054 if (0) {
29055 zval_ptr_dtor(&property);
29056 } else {
29057
29058 }
29059 FREE_OP(free_op_data1);
29060 }
29061
29062 /* assign_obj has two opcodes! */
29063 CHECK_EXCEPTION();
29064 ZEND_VM_INC_OPCODE();
29065 ZEND_VM_NEXT_OPCODE();
29066 }
29067
zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)29068 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
29069 {
29070 USE_OPLINE
29071 zend_free_op free_op_data2, free_op_data1;
29072 zval **var_ptr;
29073 zval *value;
29074
29075 SAVE_OPLINE();
29076 switch (opline->extended_value) {
29077 case ZEND_ASSIGN_OBJ:
29078 return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29079 break;
29080 case ZEND_ASSIGN_DIM: {
29081 zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29082
29083 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
29084 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29085 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
29086 if (IS_UNUSED == IS_VAR && !0) {
29087 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
29088 }
29089 return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29090 } else {
29091 zval *dim = NULL;
29092
29093 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
29094 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
29095 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
29096 }
29097 }
29098 break;
29099 default:
29100 value = NULL;
29101 var_ptr = NULL;
29102 /* do nothing */
29103 break;
29104 }
29105
29106 if (UNEXPECTED(var_ptr == NULL)) {
29107 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
29108 }
29109
29110 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
29111 if (RETURN_VALUE_USED(opline)) {
29112 PZVAL_LOCK(&EG(uninitialized_zval));
29113 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29114 }
29115
29116
29117 CHECK_EXCEPTION();
29118 if (opline->extended_value == ZEND_ASSIGN_DIM) {
29119 ZEND_VM_INC_OPCODE();
29120 }
29121 ZEND_VM_NEXT_OPCODE();
29122 }
29123
29124 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
29125
29126 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
29127 && Z_OBJ_HANDLER_PP(var_ptr, get)
29128 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
29129 /* proxy object */
29130 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
29131 Z_ADDREF_P(objval);
29132 binary_op(objval, objval, value TSRMLS_CC);
29133 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
29134 zval_ptr_dtor(&objval);
29135 } else {
29136 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
29137 }
29138
29139 if (RETURN_VALUE_USED(opline)) {
29140 PZVAL_LOCK(*var_ptr);
29141 EX_T(opline->result.var).var.ptr = *var_ptr;
29142 }
29143
29144 if (opline->extended_value == ZEND_ASSIGN_DIM) {
29145 FREE_OP(free_op_data1);
29146 FREE_OP_VAR_PTR(free_op_data2);
29147
29148 CHECK_EXCEPTION();
29149 ZEND_VM_INC_OPCODE();
29150 } else {
29151
29152 CHECK_EXCEPTION();
29153 }
29154 ZEND_VM_NEXT_OPCODE();
29155 }
29156
ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29157 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29158 {
29159 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29160 }
29161
ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29162 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29163 {
29164 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29165 }
29166
ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29167 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29168 {
29169 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29170 }
29171
ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29172 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29173 {
29174 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29175 }
29176
ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29177 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29178 {
29179 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29180 }
29181
ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29182 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29183 {
29184 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29185 }
29186
ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29187 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29188 {
29189 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29190 }
29191
ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29192 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29193 {
29194 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29195 }
29196
ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29197 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29198 {
29199 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29200 }
29201
ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29202 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29203 {
29204 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29205 }
29206
ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29207 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29208 {
29209 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29210 }
29211
ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29212 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29213 {
29214 USE_OPLINE
29215
29216 array_init(&EX_T(opline->result.var).tmp_var);
29217 if (IS_UNUSED == IS_UNUSED) {
29218 ZEND_VM_NEXT_OPCODE();
29219 #if 0 || IS_UNUSED != IS_UNUSED
29220 } else {
29221 return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29222 #endif
29223 }
29224 }
29225
ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29226 static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29227 {
29228 USE_OPLINE
29229
29230 /* The generator object is stored in return_value_ptr_ptr */
29231 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
29232
29233 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
29234 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
29235 }
29236
29237 /* Destroy the previously yielded value */
29238 if (generator->value) {
29239 zval_ptr_dtor(&generator->value);
29240 }
29241
29242 /* Destroy the previously yielded key */
29243 if (generator->key) {
29244 zval_ptr_dtor(&generator->key);
29245 }
29246
29247 /* Set the new yielded value */
29248 if (IS_UNUSED != IS_UNUSED) {
29249
29250
29251 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
29252 /* Constants and temporary variables aren't yieldable by reference,
29253 * but we still allow them with a notice. */
29254 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
29255 zval *value, *copy;
29256
29257 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
29258
29259 value = NULL;
29260 ALLOC_ZVAL(copy);
29261 INIT_PZVAL_COPY(copy, value);
29262
29263 /* Temporary variables don't need ctor copying */
29264 if (!0) {
29265 zval_copy_ctor(copy);
29266 }
29267
29268 generator->value = copy;
29269 } else {
29270 zval **value_ptr = NULL;
29271
29272 if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
29273 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
29274 }
29275
29276 /* If a function call result is yielded and the function did
29277 * not return by reference we throw a notice. */
29278 if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
29279 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
29280 && EX_T(opline->op1.var).var.fcall_returned_reference)
29281 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
29282 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
29283
29284 Z_ADDREF_PP(value_ptr);
29285 generator->value = *value_ptr;
29286 } else {
29287 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
29288 Z_ADDREF_PP(value_ptr);
29289 generator->value = *value_ptr;
29290 }
29291
29292 }
29293 } else {
29294 zval *value = NULL;
29295
29296 /* Consts, temporary variables and references need copying */
29297 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
29298 || PZVAL_IS_REF(value)
29299 ) {
29300 zval *copy;
29301
29302 ALLOC_ZVAL(copy);
29303 INIT_PZVAL_COPY(copy, value);
29304
29305 /* Temporary variables don't need ctor copying */
29306 if (!0) {
29307 zval_copy_ctor(copy);
29308 }
29309
29310 generator->value = copy;
29311
29312 } else {
29313 if (IS_UNUSED == IS_CV) {
29314 Z_ADDREF_P(value);
29315 }
29316 generator->value = value;
29317 }
29318 }
29319 } else {
29320 /* If no value was specified yield null */
29321 Z_ADDREF(EG(uninitialized_zval));
29322 generator->value = &EG(uninitialized_zval);
29323 }
29324
29325 /* Set the new yielded key */
29326 if (IS_UNUSED != IS_UNUSED) {
29327
29328 zval *key = NULL;
29329
29330 /* Consts, temporary variables and references need copying */
29331 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
29332 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
29333 ) {
29334 zval *copy;
29335
29336 ALLOC_ZVAL(copy);
29337 INIT_PZVAL_COPY(copy, key);
29338
29339 /* Temporary variables don't need ctor copying */
29340 if (!0) {
29341 zval_copy_ctor(copy);
29342 }
29343
29344 generator->key = copy;
29345 } else {
29346 Z_ADDREF_P(key);
29347 generator->key = key;
29348 }
29349
29350 if (Z_TYPE_P(generator->key) == IS_LONG
29351 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
29352 ) {
29353 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
29354 }
29355
29356 } else {
29357 /* If no key was specified we use auto-increment keys */
29358 generator->largest_used_integer_key++;
29359
29360 ALLOC_INIT_ZVAL(generator->key);
29361 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
29362 }
29363
29364 if (RETURN_VALUE_USED(opline)) {
29365 /* If the return value of yield is used set the send
29366 * target and initialize it to NULL */
29367 generator->send_target = &EX_T(opline->result.var).var.ptr;
29368 Z_ADDREF(EG(uninitialized_zval));
29369 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29370 } else {
29371 generator->send_target = NULL;
29372 }
29373
29374 /* We increment to the next op, so we are at the correct position when the
29375 * generator is resumed. */
29376 ZEND_VM_INC_OPCODE();
29377
29378 /* The GOTO VM uses a local opline variable. We need to set the opline
29379 * variable in execute_data so we don't resume at an old position. */
29380 SAVE_OPLINE();
29381
29382 ZEND_VM_RETURN();
29383 }
29384
ZEND_ASSIGN_POW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29385 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29386 {
29387 return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29388 }
29389
zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)29390 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
29391 {
29392 USE_OPLINE
29393 zend_free_op free_op_data1;
29394 zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29395 zval *object;
29396 zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29397 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
29398 int have_get_ptr = 0;
29399
29400 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
29401 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29402 }
29403
29404 make_real_object(object_ptr TSRMLS_CC);
29405 object = *object_ptr;
29406
29407 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
29408 zend_error(E_WARNING, "Attempt to assign property of non-object");
29409
29410 FREE_OP(free_op_data1);
29411
29412 if (RETURN_VALUE_USED(opline)) {
29413 PZVAL_LOCK(&EG(uninitialized_zval));
29414 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29415 }
29416 } else {
29417 /* here we are sure we are dealing with an object */
29418 if (0) {
29419 MAKE_REAL_ZVAL_PTR(property);
29420 }
29421
29422 /* here property is a string */
29423 if (opline->extended_value == ZEND_ASSIGN_OBJ
29424 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
29425 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29426 if (zptr != NULL) { /* NULL means no success in getting PTR */
29427 have_get_ptr = 1;
29428 if (UNEXPECTED(*zptr == &EG(error_zval))) {
29429 if (RETURN_VALUE_USED(opline)) {
29430 PZVAL_LOCK(&EG(uninitialized_zval));
29431 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29432 }
29433 } else {
29434 SEPARATE_ZVAL_IF_NOT_REF(zptr);
29435
29436 binary_op(*zptr, *zptr, value TSRMLS_CC);
29437 if (RETURN_VALUE_USED(opline)) {
29438 PZVAL_LOCK(*zptr);
29439 EX_T(opline->result.var).var.ptr = *zptr;
29440 }
29441 }
29442 }
29443 }
29444
29445 if (!have_get_ptr) {
29446 zval *z = NULL;
29447
29448 Z_ADDREF_P(object);
29449 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
29450 if (Z_OBJ_HT_P(object)->read_property) {
29451 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29452 }
29453 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
29454 if (Z_OBJ_HT_P(object)->read_dimension) {
29455 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
29456 }
29457 }
29458 if (z) {
29459 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
29460 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
29461
29462 if (Z_REFCOUNT_P(z) == 0) {
29463 GC_REMOVE_ZVAL_FROM_BUFFER(z);
29464 zval_dtor(z);
29465 FREE_ZVAL(z);
29466 }
29467 z = value;
29468 }
29469 Z_ADDREF_P(z);
29470 SEPARATE_ZVAL_IF_NOT_REF(&z);
29471 binary_op(z, z, value TSRMLS_CC);
29472 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
29473 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29474 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
29475 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
29476 }
29477 if (RETURN_VALUE_USED(opline)) {
29478 PZVAL_LOCK(z);
29479 EX_T(opline->result.var).var.ptr = z;
29480 }
29481 zval_ptr_dtor(&z);
29482 } else {
29483 zend_error(E_WARNING, "Attempt to assign property of non-object");
29484 if (RETURN_VALUE_USED(opline)) {
29485 PZVAL_LOCK(&EG(uninitialized_zval));
29486 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29487 }
29488 }
29489 zval_ptr_dtor(&object);
29490 }
29491
29492 if (0) {
29493 zval_ptr_dtor(&property);
29494 } else {
29495
29496 }
29497 FREE_OP(free_op_data1);
29498 }
29499
29500 /* assign_obj has two opcodes! */
29501 CHECK_EXCEPTION();
29502 ZEND_VM_INC_OPCODE();
29503 ZEND_VM_NEXT_OPCODE();
29504 }
29505
zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)29506 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
29507 {
29508 USE_OPLINE
29509 zend_free_op free_op_data2, free_op_data1;
29510 zval **var_ptr;
29511 zval *value;
29512
29513 SAVE_OPLINE();
29514 switch (opline->extended_value) {
29515 case ZEND_ASSIGN_OBJ:
29516 return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29517 break;
29518 case ZEND_ASSIGN_DIM: {
29519 zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29520
29521 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
29522 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29523 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
29524 if (IS_UNUSED == IS_VAR && !0) {
29525 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
29526 }
29527 return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29528 } else {
29529 zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29530
29531 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC);
29532 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
29533 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
29534 }
29535 }
29536 break;
29537 default:
29538 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29539 var_ptr = NULL;
29540 /* do nothing */
29541 break;
29542 }
29543
29544 if (UNEXPECTED(var_ptr == NULL)) {
29545 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
29546 }
29547
29548 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
29549 if (RETURN_VALUE_USED(opline)) {
29550 PZVAL_LOCK(&EG(uninitialized_zval));
29551 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29552 }
29553
29554
29555 CHECK_EXCEPTION();
29556 if (opline->extended_value == ZEND_ASSIGN_DIM) {
29557 ZEND_VM_INC_OPCODE();
29558 }
29559 ZEND_VM_NEXT_OPCODE();
29560 }
29561
29562 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
29563
29564 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
29565 && Z_OBJ_HANDLER_PP(var_ptr, get)
29566 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
29567 /* proxy object */
29568 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
29569 Z_ADDREF_P(objval);
29570 binary_op(objval, objval, value TSRMLS_CC);
29571 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
29572 zval_ptr_dtor(&objval);
29573 } else {
29574 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
29575 }
29576
29577 if (RETURN_VALUE_USED(opline)) {
29578 PZVAL_LOCK(*var_ptr);
29579 EX_T(opline->result.var).var.ptr = *var_ptr;
29580 }
29581
29582 if (opline->extended_value == ZEND_ASSIGN_DIM) {
29583 FREE_OP(free_op_data1);
29584 FREE_OP_VAR_PTR(free_op_data2);
29585
29586 CHECK_EXCEPTION();
29587 ZEND_VM_INC_OPCODE();
29588 } else {
29589
29590 CHECK_EXCEPTION();
29591 }
29592 ZEND_VM_NEXT_OPCODE();
29593 }
29594
ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29595 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29596 {
29597 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29598 }
29599
ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29600 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29601 {
29602 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29603 }
29604
ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29605 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29606 {
29607 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29608 }
29609
ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29610 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29611 {
29612 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29613 }
29614
ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29615 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29616 {
29617 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29618 }
29619
ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29620 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29621 {
29622 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29623 }
29624
ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29625 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29626 {
29627 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29628 }
29629
ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29630 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29631 {
29632 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29633 }
29634
ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29635 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29636 {
29637 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29638 }
29639
ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29640 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29641 {
29642 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29643 }
29644
ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29645 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29646 {
29647 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29648 }
29649
zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)29650 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
29651 {
29652 USE_OPLINE
29653
29654 zval **object_ptr;
29655 zval *object;
29656 zval *property;
29657 zval **retval;
29658 int have_get_ptr = 0;
29659
29660 SAVE_OPLINE();
29661 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29662 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29663 retval = &EX_T(opline->result.var).var.ptr;
29664
29665 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
29666 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
29667 }
29668
29669 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
29670 object = *object_ptr;
29671
29672 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
29673 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
29674
29675 if (RETURN_VALUE_USED(opline)) {
29676 PZVAL_LOCK(&EG(uninitialized_zval));
29677 *retval = &EG(uninitialized_zval);
29678 }
29679
29680 CHECK_EXCEPTION();
29681 ZEND_VM_NEXT_OPCODE();
29682 }
29683
29684 /* here we are sure we are dealing with an object */
29685
29686 if (0) {
29687 MAKE_REAL_ZVAL_PTR(property);
29688 }
29689
29690 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
29691 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29692 if (zptr != NULL) { /* NULL means no success in getting PTR */
29693 have_get_ptr = 1;
29694 if (UNEXPECTED(*zptr == &EG(error_zval))) {
29695 if (RETURN_VALUE_USED(opline)) {
29696 PZVAL_LOCK(&EG(uninitialized_zval));
29697 *retval = &EG(uninitialized_zval);
29698 }
29699 } else {
29700 SEPARATE_ZVAL_IF_NOT_REF(zptr);
29701
29702 incdec_op(*zptr);
29703 if (RETURN_VALUE_USED(opline)) {
29704 *retval = *zptr;
29705 PZVAL_LOCK(*retval);
29706 }
29707 }
29708 }
29709 }
29710
29711 if (!have_get_ptr) {
29712 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
29713 zval *z;
29714
29715 Z_ADDREF_P(object);
29716 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29717
29718 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
29719 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
29720
29721 if (Z_REFCOUNT_P(z) == 0) {
29722 GC_REMOVE_ZVAL_FROM_BUFFER(z);
29723 zval_dtor(z);
29724 FREE_ZVAL(z);
29725 }
29726 z = value;
29727 }
29728 Z_ADDREF_P(z);
29729 SEPARATE_ZVAL_IF_NOT_REF(&z);
29730 incdec_op(z);
29731 *retval = z;
29732 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29733 zval_ptr_dtor(&object);
29734 SELECTIVE_PZVAL_LOCK(*retval, opline);
29735 zval_ptr_dtor(&z);
29736 } else {
29737 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
29738 if (RETURN_VALUE_USED(opline)) {
29739 PZVAL_LOCK(&EG(uninitialized_zval));
29740 *retval = &EG(uninitialized_zval);
29741 }
29742 }
29743 }
29744
29745 if (0) {
29746 zval_ptr_dtor(&property);
29747 } else {
29748
29749 }
29750
29751 CHECK_EXCEPTION();
29752 ZEND_VM_NEXT_OPCODE();
29753 }
29754
ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29755 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29756 {
29757 return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29758 }
29759
ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29760 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29761 {
29762 return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29763 }
29764
zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)29765 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
29766 {
29767 USE_OPLINE
29768
29769 zval **object_ptr;
29770 zval *object;
29771 zval *property;
29772 zval *retval;
29773 int have_get_ptr = 0;
29774
29775 SAVE_OPLINE();
29776 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29777 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29778 retval = &EX_T(opline->result.var).tmp_var;
29779
29780 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
29781 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
29782 }
29783
29784 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
29785 object = *object_ptr;
29786
29787 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
29788 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
29789
29790 ZVAL_NULL(retval);
29791
29792 CHECK_EXCEPTION();
29793 ZEND_VM_NEXT_OPCODE();
29794 }
29795
29796 /* here we are sure we are dealing with an object */
29797
29798 if (0) {
29799 MAKE_REAL_ZVAL_PTR(property);
29800 }
29801
29802 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
29803 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29804 if (zptr != NULL) { /* NULL means no success in getting PTR */
29805 have_get_ptr = 1;
29806 if (UNEXPECTED(*zptr == &EG(error_zval))) {
29807 ZVAL_NULL(retval);
29808 } else {
29809 SEPARATE_ZVAL_IF_NOT_REF(zptr);
29810
29811 ZVAL_COPY_VALUE(retval, *zptr);
29812 zendi_zval_copy_ctor(*retval);
29813
29814 incdec_op(*zptr);
29815 }
29816 }
29817 }
29818
29819 if (!have_get_ptr) {
29820 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
29821 zval *z, *z_copy;
29822
29823 Z_ADDREF_P(object);
29824 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29825 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
29826 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
29827
29828 if (Z_REFCOUNT_P(z) == 0) {
29829 GC_REMOVE_ZVAL_FROM_BUFFER(z);
29830 zval_dtor(z);
29831 FREE_ZVAL(z);
29832 }
29833 z = value;
29834 }
29835 ZVAL_COPY_VALUE(retval, z);
29836 zendi_zval_copy_ctor(*retval);
29837 ALLOC_ZVAL(z_copy);
29838 INIT_PZVAL_COPY(z_copy, z);
29839 zendi_zval_copy_ctor(*z_copy);
29840 incdec_op(z_copy);
29841 Z_ADDREF_P(z);
29842 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29843 zval_ptr_dtor(&object);
29844 zval_ptr_dtor(&z_copy);
29845 zval_ptr_dtor(&z);
29846 } else {
29847 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
29848 ZVAL_NULL(retval);
29849 }
29850 }
29851
29852 if (0) {
29853 zval_ptr_dtor(&property);
29854 } else {
29855
29856 }
29857
29858 CHECK_EXCEPTION();
29859 ZEND_VM_NEXT_OPCODE();
29860 }
29861
ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29862 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29863 {
29864 return zend_post_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29865 }
29866
ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29867 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29868 {
29869 return zend_post_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29870 }
29871
zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS)29872 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS)
29873 {
29874 USE_OPLINE
29875
29876 zval *container;
29877
29878 zval *offset;
29879
29880 SAVE_OPLINE();
29881 container = _get_obj_zval_ptr_unused(TSRMLS_C);
29882 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29883
29884 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
29885 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
29886 zend_error(E_NOTICE, "Trying to get property of non-object");
29887 PZVAL_LOCK(&EG(uninitialized_zval));
29888 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29889
29890 } else {
29891 zval *retval;
29892
29893 if (0) {
29894 MAKE_REAL_ZVAL_PTR(offset);
29895 }
29896
29897 /* here we are sure we are dealing with an object */
29898 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29899
29900 PZVAL_LOCK(retval);
29901 EX_T(opline->result.var).var.ptr = retval;
29902
29903 if (0) {
29904 zval_ptr_dtor(&offset);
29905 } else {
29906
29907 }
29908 }
29909
29910 CHECK_EXCEPTION();
29911 ZEND_VM_NEXT_OPCODE();
29912 }
29913
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29914 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29915 {
29916 return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29917 }
29918
ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29919 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29920 {
29921 USE_OPLINE
29922 zend_free_op free_op1;
29923 zval *property;
29924 zval **container;
29925
29926 SAVE_OPLINE();
29927 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29928
29929 if (0) {
29930 MAKE_REAL_ZVAL_PTR(property);
29931 }
29932 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29933 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
29934 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29935 }
29936
29937 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
29938 if (0) {
29939 zval_ptr_dtor(&property);
29940 } else {
29941
29942 }
29943 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
29944 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
29945 }
29946
29947 /* We are going to assign the result by reference */
29948 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
29949 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
29950
29951 Z_DELREF_PP(retval_ptr);
29952 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
29953 Z_ADDREF_PP(retval_ptr);
29954 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
29955 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
29956 }
29957
29958 CHECK_EXCEPTION();
29959 ZEND_VM_NEXT_OPCODE();
29960 }
29961
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29962 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29963 {
29964 USE_OPLINE
29965 zend_free_op free_op1;
29966 zval *property;
29967 zval **container;
29968
29969 SAVE_OPLINE();
29970 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29971 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29972
29973 if (0) {
29974 MAKE_REAL_ZVAL_PTR(property);
29975 }
29976 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
29977 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29978 }
29979 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
29980 if (0) {
29981 zval_ptr_dtor(&property);
29982 } else {
29983
29984 }
29985 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
29986 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
29987 }
29988
29989 CHECK_EXCEPTION();
29990 ZEND_VM_NEXT_OPCODE();
29991 }
29992
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29993 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29994 {
29995 USE_OPLINE
29996
29997 zval *container;
29998
29999 zval *offset;
30000
30001 SAVE_OPLINE();
30002 container = _get_obj_zval_ptr_unused(TSRMLS_C);
30003 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30004
30005 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
30006 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
30007 PZVAL_LOCK(&EG(uninitialized_zval));
30008 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
30009
30010 } else {
30011 zval *retval;
30012
30013 if (0) {
30014 MAKE_REAL_ZVAL_PTR(offset);
30015 }
30016
30017 /* here we are sure we are dealing with an object */
30018 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
30019
30020 PZVAL_LOCK(retval);
30021 EX_T(opline->result.var).var.ptr = retval;
30022
30023 if (0) {
30024 zval_ptr_dtor(&offset);
30025 } else {
30026
30027 }
30028 }
30029
30030 CHECK_EXCEPTION();
30031 ZEND_VM_NEXT_OPCODE();
30032 }
30033
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30034 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30035 {
30036 USE_OPLINE
30037
30038 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
30039 /* Behave like FETCH_OBJ_W */
30040 zend_free_op free_op1;
30041 zval *property;
30042 zval **container;
30043
30044 SAVE_OPLINE();
30045 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30046 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
30047
30048 if (0) {
30049 MAKE_REAL_ZVAL_PTR(property);
30050 }
30051 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
30052 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
30053 }
30054 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
30055 if (0) {
30056 zval_ptr_dtor(&property);
30057 } else {
30058
30059 }
30060 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
30061 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
30062 }
30063
30064 CHECK_EXCEPTION();
30065 ZEND_VM_NEXT_OPCODE();
30066 } else {
30067 return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30068 }
30069 }
30070
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30071 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30072 {
30073 USE_OPLINE
30074 zend_free_op free_op1, free_res;
30075 zval **container;
30076 zval *property;
30077
30078 SAVE_OPLINE();
30079 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
30080 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30081
30082 if (IS_UNUSED == IS_CV) {
30083 if (container != &EG(uninitialized_zval_ptr)) {
30084 SEPARATE_ZVAL_IF_NOT_REF(container);
30085 }
30086 }
30087 if (0) {
30088 MAKE_REAL_ZVAL_PTR(property);
30089 }
30090 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
30091 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
30092 }
30093 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
30094 if (0) {
30095 zval_ptr_dtor(&property);
30096 } else {
30097
30098 }
30099 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
30100 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
30101 }
30102
30103 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
30104 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
30105 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
30106 }
30107 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
30108 FREE_OP_VAR_PTR(free_res);
30109 CHECK_EXCEPTION();
30110 ZEND_VM_NEXT_OPCODE();
30111 }
30112
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30113 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30114 {
30115 USE_OPLINE
30116
30117 zval **object_ptr;
30118 zval *property_name;
30119
30120 SAVE_OPLINE();
30121 object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
30122 property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30123
30124 if (0) {
30125 MAKE_REAL_ZVAL_PTR(property_name);
30126 }
30127 if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
30128 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
30129 }
30130 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
30131 if (0) {
30132 zval_ptr_dtor(&property_name);
30133 } else {
30134
30135 }
30136
30137 /* assign_obj has two opcodes! */
30138 CHECK_EXCEPTION();
30139 ZEND_VM_INC_OPCODE();
30140 ZEND_VM_NEXT_OPCODE();
30141 }
30142
ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30143 static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30144 {
30145 USE_OPLINE
30146
30147 zval *str = &EX_T(opline->result.var).tmp_var;
30148 zval *var;
30149 zval var_copy;
30150 int use_copy = 0;
30151
30152 SAVE_OPLINE();
30153 var = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30154
30155 if (IS_UNUSED == IS_UNUSED) {
30156 /* Initialize for erealloc in add_string_to_string */
30157 Z_STRVAL_P(str) = NULL;
30158 Z_STRLEN_P(str) = 0;
30159 Z_TYPE_P(str) = IS_STRING;
30160
30161 INIT_PZVAL(str);
30162 }
30163
30164 if (Z_TYPE_P(var) != IS_STRING) {
30165 zend_make_printable_zval(var, &var_copy, &use_copy);
30166
30167 if (use_copy) {
30168 var = &var_copy;
30169 }
30170 }
30171 add_string_to_string(str, str, var);
30172
30173 if (use_copy) {
30174 zval_dtor(var);
30175 }
30176 /* original comment, possibly problematic:
30177 * FREE_OP is missing intentionally here - we're always working on the same temporary variable
30178 * (Zeev): I don't think it's problematic, we only use variables
30179 * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
30180 * string offsets or overloaded objects
30181 */
30182
30183 CHECK_EXCEPTION();
30184 ZEND_VM_NEXT_OPCODE();
30185 }
30186
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30187 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30188 {
30189 USE_OPLINE
30190 zval *function_name;
30191 char *function_name_strval;
30192 int function_name_strlen;
30193
30194 call_slot *call = EX(call_slots) + opline->result.num;
30195
30196 SAVE_OPLINE();
30197
30198 function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30199
30200 if (IS_CV != IS_CONST &&
30201 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
30202 if (UNEXPECTED(EG(exception) != NULL)) {
30203 HANDLE_EXCEPTION();
30204 }
30205 zend_error_noreturn(E_ERROR, "Method name must be a string");
30206 }
30207
30208 function_name_strval = Z_STRVAL_P(function_name);
30209 function_name_strlen = Z_STRLEN_P(function_name);
30210
30211 call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
30212
30213 if (EXPECTED(call->object != NULL) &&
30214 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
30215 call->called_scope = Z_OBJCE_P(call->object);
30216
30217 if (IS_CV != IS_CONST ||
30218 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
30219 zval *object = call->object;
30220
30221 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
30222 zend_error_noreturn(E_ERROR, "Object does not support method calls");
30223 }
30224
30225 /* First, locate the function. */
30226 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
30227 if (UNEXPECTED(call->fbc == NULL)) {
30228 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
30229 }
30230 if (IS_CV == IS_CONST &&
30231 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
30232 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
30233 EXPECTED(call->object == object)) {
30234 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
30235 }
30236 }
30237 } else {
30238 if (UNEXPECTED(EG(exception) != NULL)) {
30239
30240 HANDLE_EXCEPTION();
30241 }
30242 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
30243 }
30244
30245 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
30246 call->object = NULL;
30247 } else {
30248 if (!PZVAL_IS_REF(call->object)) {
30249 Z_ADDREF_P(call->object); /* For $this pointer */
30250 } else {
30251 zval *this_ptr;
30252 ALLOC_ZVAL(this_ptr);
30253 INIT_PZVAL_COPY(this_ptr, call->object);
30254 zval_copy_ctor(this_ptr);
30255 call->object = this_ptr;
30256 }
30257 }
30258
30259 call->num_additional_args = 0;
30260 call->is_ctor_call = 0;
30261 EX(call) = call;
30262
30263
30264 CHECK_EXCEPTION();
30265 ZEND_VM_NEXT_OPCODE();
30266 }
30267
ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30268 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30269 {
30270 USE_OPLINE
30271
30272 array_init(&EX_T(opline->result.var).tmp_var);
30273 if (IS_UNUSED == IS_UNUSED) {
30274 ZEND_VM_NEXT_OPCODE();
30275 #if 0 || IS_UNUSED != IS_UNUSED
30276 } else {
30277 return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30278 #endif
30279 }
30280 }
30281
ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30282 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30283 {
30284 USE_OPLINE
30285
30286 zval **container;
30287 zval *offset;
30288 ulong hval;
30289
30290 SAVE_OPLINE();
30291 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
30292 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
30293 SEPARATE_ZVAL_IF_NOT_REF(container);
30294 }
30295 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30296
30297 if (IS_UNUSED != IS_VAR || container) {
30298 switch (Z_TYPE_PP(container)) {
30299 case IS_ARRAY: {
30300 HashTable *ht = Z_ARRVAL_PP(container);
30301
30302 switch (Z_TYPE_P(offset)) {
30303 case IS_DOUBLE:
30304 hval = zend_dval_to_lval(Z_DVAL_P(offset));
30305 zend_hash_index_del(ht, hval);
30306 break;
30307 case IS_RESOURCE:
30308 case IS_BOOL:
30309 case IS_LONG:
30310 hval = Z_LVAL_P(offset);
30311 zend_hash_index_del(ht, hval);
30312 break;
30313 case IS_STRING:
30314 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
30315 Z_ADDREF_P(offset);
30316 }
30317 if (IS_CV == IS_CONST) {
30318 hval = Z_HASH_P(offset);
30319 } else {
30320 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
30321 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
30322 }
30323 if (ht == &EG(symbol_table)) {
30324 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
30325 } else {
30326 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
30327 }
30328 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
30329 zval_ptr_dtor(&offset);
30330 }
30331 break;
30332 num_index_dim:
30333 zend_hash_index_del(ht, hval);
30334 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
30335 zval_ptr_dtor(&offset);
30336 }
30337 break;
30338 case IS_NULL:
30339 zend_hash_del(ht, "", sizeof(""));
30340 break;
30341 default:
30342 zend_error(E_WARNING, "Illegal offset type in unset");
30343 break;
30344 }
30345
30346 break;
30347 }
30348 case IS_OBJECT:
30349 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
30350 zend_error_noreturn(E_ERROR, "Cannot use object as array");
30351 }
30352 if (0) {
30353 MAKE_REAL_ZVAL_PTR(offset);
30354 }
30355 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
30356 if (0) {
30357 zval_ptr_dtor(&offset);
30358 } else {
30359
30360 }
30361 break;
30362 case IS_STRING:
30363 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
30364 ZEND_VM_CONTINUE(); /* bailed out before */
30365 default:
30366
30367 break;
30368 }
30369 } else {
30370
30371 }
30372
30373 CHECK_EXCEPTION();
30374 ZEND_VM_NEXT_OPCODE();
30375 }
30376
ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30377 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30378 {
30379 USE_OPLINE
30380
30381 zval **container;
30382 zval *offset;
30383
30384 SAVE_OPLINE();
30385 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
30386 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30387
30388 if (IS_UNUSED != IS_VAR || container) {
30389 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
30390 SEPARATE_ZVAL_IF_NOT_REF(container);
30391 }
30392 if (Z_TYPE_PP(container) == IS_OBJECT) {
30393 if (0) {
30394 MAKE_REAL_ZVAL_PTR(offset);
30395 }
30396 if (Z_OBJ_HT_P(*container)->unset_property) {
30397 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
30398 } else {
30399 zend_error(E_NOTICE, "Trying to unset property of non-object");
30400 }
30401 if (0) {
30402 zval_ptr_dtor(&offset);
30403 } else {
30404
30405 }
30406 } else {
30407
30408 }
30409 } else {
30410
30411 }
30412
30413 CHECK_EXCEPTION();
30414 ZEND_VM_NEXT_OPCODE();
30415 }
30416
zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)30417 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
30418 {
30419 USE_OPLINE
30420
30421 zval *container;
30422 zval **value = NULL;
30423 int result = 0;
30424 ulong hval;
30425 zval *offset;
30426
30427 SAVE_OPLINE();
30428 container = _get_obj_zval_ptr_unused(TSRMLS_C);
30429 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30430
30431 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
30432 HashTable *ht;
30433 int isset = 0;
30434
30435 ht = Z_ARRVAL_P(container);
30436
30437 switch (Z_TYPE_P(offset)) {
30438 case IS_DOUBLE:
30439 hval = zend_dval_to_lval(Z_DVAL_P(offset));
30440 goto num_index_prop;
30441 case IS_RESOURCE:
30442 case IS_BOOL:
30443 case IS_LONG:
30444 hval = Z_LVAL_P(offset);
30445 num_index_prop:
30446 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
30447 isset = 1;
30448 }
30449 break;
30450 case IS_STRING:
30451 if (IS_CV == IS_CONST) {
30452 hval = Z_HASH_P(offset);
30453 } else {
30454 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
30455 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
30456 }
30457 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
30458 isset = 1;
30459 }
30460 break;
30461 case IS_NULL:
30462 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
30463 isset = 1;
30464 }
30465 break;
30466 default:
30467 zend_error(E_WARNING, "Illegal offset type in isset or empty");
30468 break;
30469 }
30470
30471 if (opline->extended_value & ZEND_ISSET) {
30472 if (isset && Z_TYPE_PP(value) == IS_NULL) {
30473 result = 0;
30474 } else {
30475 result = isset;
30476 }
30477 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
30478 if (!isset || !i_zend_is_true(*value)) {
30479 result = 0;
30480 } else {
30481 result = 1;
30482 }
30483 }
30484
30485 } else if (Z_TYPE_P(container) == IS_OBJECT) {
30486 if (0) {
30487 MAKE_REAL_ZVAL_PTR(offset);
30488 }
30489 if (prop_dim) {
30490 if (Z_OBJ_HT_P(container)->has_property) {
30491 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
30492 } else {
30493 zend_error(E_NOTICE, "Trying to check property of non-object");
30494 result = 0;
30495 }
30496 } else {
30497 if (Z_OBJ_HT_P(container)->has_dimension) {
30498 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
30499 } else {
30500 zend_error(E_NOTICE, "Trying to check element of non-array");
30501 result = 0;
30502 }
30503 }
30504 if (0) {
30505 zval_ptr_dtor(&offset);
30506 } else {
30507
30508 }
30509 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
30510 zval tmp;
30511
30512 if (Z_TYPE_P(offset) != IS_LONG) {
30513 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
30514 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
30515 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
30516 ZVAL_COPY_VALUE(&tmp, offset);
30517 zval_copy_ctor(&tmp);
30518 convert_to_long(&tmp);
30519 offset = &tmp;
30520 } else {
30521 /* can not be converted to proper offset, return "not set" */
30522 result = 0;
30523 }
30524 }
30525 if (Z_TYPE_P(offset) == IS_LONG) {
30526 if (opline->extended_value & ZEND_ISSET) {
30527 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
30528 result = 1;
30529 }
30530 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
30531 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
30532 result = 1;
30533 }
30534 }
30535 }
30536
30537 } else {
30538
30539 }
30540
30541 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
30542 if (opline->extended_value & ZEND_ISSET) {
30543 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
30544 } else {
30545 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
30546 }
30547
30548 CHECK_EXCEPTION();
30549 ZEND_VM_NEXT_OPCODE();
30550 }
30551
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30552 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30553 {
30554 return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30555 }
30556
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30557 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30558 {
30559 return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30560 }
30561
ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30562 static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30563 {
30564 USE_OPLINE
30565
30566 /* The generator object is stored in return_value_ptr_ptr */
30567 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
30568
30569 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
30570 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
30571 }
30572
30573 /* Destroy the previously yielded value */
30574 if (generator->value) {
30575 zval_ptr_dtor(&generator->value);
30576 }
30577
30578 /* Destroy the previously yielded key */
30579 if (generator->key) {
30580 zval_ptr_dtor(&generator->key);
30581 }
30582
30583 /* Set the new yielded value */
30584 if (IS_UNUSED != IS_UNUSED) {
30585
30586
30587 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
30588 /* Constants and temporary variables aren't yieldable by reference,
30589 * but we still allow them with a notice. */
30590 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
30591 zval *value, *copy;
30592
30593 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30594
30595 value = NULL;
30596 ALLOC_ZVAL(copy);
30597 INIT_PZVAL_COPY(copy, value);
30598
30599 /* Temporary variables don't need ctor copying */
30600 if (!0) {
30601 zval_copy_ctor(copy);
30602 }
30603
30604 generator->value = copy;
30605 } else {
30606 zval **value_ptr = NULL;
30607
30608 if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
30609 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
30610 }
30611
30612 /* If a function call result is yielded and the function did
30613 * not return by reference we throw a notice. */
30614 if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
30615 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
30616 && EX_T(opline->op1.var).var.fcall_returned_reference)
30617 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
30618 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30619
30620 Z_ADDREF_PP(value_ptr);
30621 generator->value = *value_ptr;
30622 } else {
30623 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
30624 Z_ADDREF_PP(value_ptr);
30625 generator->value = *value_ptr;
30626 }
30627
30628 }
30629 } else {
30630 zval *value = NULL;
30631
30632 /* Consts, temporary variables and references need copying */
30633 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
30634 || PZVAL_IS_REF(value)
30635 ) {
30636 zval *copy;
30637
30638 ALLOC_ZVAL(copy);
30639 INIT_PZVAL_COPY(copy, value);
30640
30641 /* Temporary variables don't need ctor copying */
30642 if (!0) {
30643 zval_copy_ctor(copy);
30644 }
30645
30646 generator->value = copy;
30647
30648 } else {
30649 if (IS_UNUSED == IS_CV) {
30650 Z_ADDREF_P(value);
30651 }
30652 generator->value = value;
30653 }
30654 }
30655 } else {
30656 /* If no value was specified yield null */
30657 Z_ADDREF(EG(uninitialized_zval));
30658 generator->value = &EG(uninitialized_zval);
30659 }
30660
30661 /* Set the new yielded key */
30662 if (IS_CV != IS_UNUSED) {
30663
30664 zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30665
30666 /* Consts, temporary variables and references need copying */
30667 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
30668 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
30669 ) {
30670 zval *copy;
30671
30672 ALLOC_ZVAL(copy);
30673 INIT_PZVAL_COPY(copy, key);
30674
30675 /* Temporary variables don't need ctor copying */
30676 if (!0) {
30677 zval_copy_ctor(copy);
30678 }
30679
30680 generator->key = copy;
30681 } else {
30682 Z_ADDREF_P(key);
30683 generator->key = key;
30684 }
30685
30686 if (Z_TYPE_P(generator->key) == IS_LONG
30687 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
30688 ) {
30689 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
30690 }
30691
30692 } else {
30693 /* If no key was specified we use auto-increment keys */
30694 generator->largest_used_integer_key++;
30695
30696 ALLOC_INIT_ZVAL(generator->key);
30697 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
30698 }
30699
30700 if (RETURN_VALUE_USED(opline)) {
30701 /* If the return value of yield is used set the send
30702 * target and initialize it to NULL */
30703 generator->send_target = &EX_T(opline->result.var).var.ptr;
30704 Z_ADDREF(EG(uninitialized_zval));
30705 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
30706 } else {
30707 generator->send_target = NULL;
30708 }
30709
30710 /* We increment to the next op, so we are at the correct position when the
30711 * generator is resumed. */
30712 ZEND_VM_INC_OPCODE();
30713
30714 /* The GOTO VM uses a local opline variable. We need to set the opline
30715 * variable in execute_data so we don't resume at an old position. */
30716 SAVE_OPLINE();
30717
30718 ZEND_VM_RETURN();
30719 }
30720
ZEND_ASSIGN_POW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30721 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30722 {
30723 return zend_binary_assign_op_helper_SPEC_UNUSED_CV(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30724 }
30725
ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30726 static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30727 {
30728 USE_OPLINE
30729
30730
30731 SAVE_OPLINE();
30732 bitwise_not_function(&EX_T(opline->result.var).tmp_var,
30733 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC);
30734
30735 CHECK_EXCEPTION();
30736 ZEND_VM_NEXT_OPCODE();
30737 }
30738
ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30739 static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30740 {
30741 USE_OPLINE
30742
30743
30744 SAVE_OPLINE();
30745 boolean_not_function(&EX_T(opline->result.var).tmp_var,
30746 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC);
30747
30748 CHECK_EXCEPTION();
30749 ZEND_VM_NEXT_OPCODE();
30750 }
30751
ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30752 static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30753 {
30754 USE_OPLINE
30755
30756 zval **var_ptr;
30757
30758 SAVE_OPLINE();
30759 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
30760
30761 if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
30762 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
30763 }
30764 if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
30765 if (RETURN_VALUE_USED(opline)) {
30766 PZVAL_LOCK(&EG(uninitialized_zval));
30767 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
30768 }
30769
30770 CHECK_EXCEPTION();
30771 ZEND_VM_NEXT_OPCODE();
30772 }
30773
30774 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
30775
30776 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
30777 && Z_OBJ_HANDLER_PP(var_ptr, get)
30778 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
30779 /* proxy object */
30780 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
30781 Z_ADDREF_P(val);
30782 fast_increment_function(val);
30783 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
30784 zval_ptr_dtor(&val);
30785 } else {
30786 fast_increment_function(*var_ptr);
30787 }
30788
30789 if (RETURN_VALUE_USED(opline)) {
30790 PZVAL_LOCK(*var_ptr);
30791 EX_T(opline->result.var).var.ptr = *var_ptr;
30792 }
30793
30794 CHECK_EXCEPTION();
30795 ZEND_VM_NEXT_OPCODE();
30796 }
30797
ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30798 static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30799 {
30800 USE_OPLINE
30801
30802 zval **var_ptr;
30803
30804 SAVE_OPLINE();
30805 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
30806
30807 if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
30808 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
30809 }
30810 if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
30811 if (RETURN_VALUE_USED(opline)) {
30812 PZVAL_LOCK(&EG(uninitialized_zval));
30813 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
30814 }
30815
30816 CHECK_EXCEPTION();
30817 ZEND_VM_NEXT_OPCODE();
30818 }
30819
30820 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
30821
30822 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
30823 && Z_OBJ_HANDLER_PP(var_ptr, get)
30824 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
30825 /* proxy object */
30826 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
30827 Z_ADDREF_P(val);
30828 fast_decrement_function(val);
30829 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
30830 zval_ptr_dtor(&val);
30831 } else {
30832 fast_decrement_function(*var_ptr);
30833 }
30834
30835 if (RETURN_VALUE_USED(opline)) {
30836 PZVAL_LOCK(*var_ptr);
30837 EX_T(opline->result.var).var.ptr = *var_ptr;
30838 }
30839
30840 CHECK_EXCEPTION();
30841 ZEND_VM_NEXT_OPCODE();
30842 }
30843
ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30844 static int ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30845 {
30846 USE_OPLINE
30847
30848 zval **var_ptr, *retval;
30849
30850 SAVE_OPLINE();
30851 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
30852
30853 if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
30854 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
30855 }
30856 if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
30857 ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
30858
30859 CHECK_EXCEPTION();
30860 ZEND_VM_NEXT_OPCODE();
30861 }
30862
30863 retval = &EX_T(opline->result.var).tmp_var;
30864 ZVAL_COPY_VALUE(retval, *var_ptr);
30865 zendi_zval_copy_ctor(*retval);
30866
30867 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
30868
30869 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
30870 && Z_OBJ_HANDLER_PP(var_ptr, get)
30871 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
30872 /* proxy object */
30873 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
30874 Z_ADDREF_P(val);
30875 fast_increment_function(val);
30876 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
30877 zval_ptr_dtor(&val);
30878 } else {
30879 fast_increment_function(*var_ptr);
30880 }
30881
30882 CHECK_EXCEPTION();
30883 ZEND_VM_NEXT_OPCODE();
30884 }
30885
ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30886 static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30887 {
30888 USE_OPLINE
30889
30890 zval **var_ptr, *retval;
30891
30892 SAVE_OPLINE();
30893 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
30894
30895 if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
30896 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
30897 }
30898 if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
30899 ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
30900
30901 CHECK_EXCEPTION();
30902 ZEND_VM_NEXT_OPCODE();
30903 }
30904
30905 retval = &EX_T(opline->result.var).tmp_var;
30906 ZVAL_COPY_VALUE(retval, *var_ptr);
30907 zendi_zval_copy_ctor(*retval);
30908
30909 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
30910
30911 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
30912 && Z_OBJ_HANDLER_PP(var_ptr, get)
30913 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
30914 /* proxy object */
30915 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
30916 Z_ADDREF_P(val);
30917 fast_decrement_function(val);
30918 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
30919 zval_ptr_dtor(&val);
30920 } else {
30921 fast_decrement_function(*var_ptr);
30922 }
30923
30924 CHECK_EXCEPTION();
30925 ZEND_VM_NEXT_OPCODE();
30926 }
30927
ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30928 static int ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30929 {
30930 USE_OPLINE
30931
30932 zval *z;
30933
30934 SAVE_OPLINE();
30935 z = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30936
30937 if (IS_CV == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
30938 INIT_PZVAL(z);
30939 }
30940 zend_print_variable(z);
30941
30942 CHECK_EXCEPTION();
30943 ZEND_VM_NEXT_OPCODE();
30944 }
30945
ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30946 static int ZEND_FASTCALL ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30947 {
30948 USE_OPLINE
30949
30950 ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
30951 return ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30952 }
30953
ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30954 static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30955 {
30956 USE_OPLINE
30957
30958 zval *val;
30959 int ret;
30960
30961 SAVE_OPLINE();
30962 val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30963
30964 if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
30965 ret = Z_LVAL_P(val);
30966 } else {
30967 ret = i_zend_is_true(val);
30968
30969 if (UNEXPECTED(EG(exception) != NULL)) {
30970 HANDLE_EXCEPTION();
30971 }
30972 }
30973 if (!ret) {
30974 #if DEBUG_ZEND>=2
30975 printf("Conditional jmp to %d\n", opline->op2.opline_num);
30976 #endif
30977 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
30978 ZEND_VM_CONTINUE();
30979 }
30980
30981 ZEND_VM_NEXT_OPCODE();
30982 }
30983
ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30984 static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30985 {
30986 USE_OPLINE
30987
30988 zval *val;
30989 int ret;
30990
30991 SAVE_OPLINE();
30992 val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30993
30994 if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
30995 ret = Z_LVAL_P(val);
30996 } else {
30997 ret = i_zend_is_true(val);
30998
30999 if (UNEXPECTED(EG(exception) != NULL)) {
31000 HANDLE_EXCEPTION();
31001 }
31002 }
31003 if (ret) {
31004 #if DEBUG_ZEND>=2
31005 printf("Conditional jmp to %d\n", opline->op2.opline_num);
31006 #endif
31007 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
31008 ZEND_VM_CONTINUE();
31009 }
31010
31011 ZEND_VM_NEXT_OPCODE();
31012 }
31013
ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31014 static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31015 {
31016 USE_OPLINE
31017
31018 zval *val;
31019 int retval;
31020
31021 SAVE_OPLINE();
31022 val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31023
31024 if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
31025 retval = Z_LVAL_P(val);
31026 } else {
31027 retval = i_zend_is_true(val);
31028
31029 if (UNEXPECTED(EG(exception) != NULL)) {
31030 HANDLE_EXCEPTION();
31031 }
31032 }
31033 if (EXPECTED(retval != 0)) {
31034 #if DEBUG_ZEND>=2
31035 printf("Conditional jmp on true to %d\n", opline->extended_value);
31036 #endif
31037 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
31038 ZEND_VM_CONTINUE(); /* CHECK_ME */
31039 } else {
31040 #if DEBUG_ZEND>=2
31041 printf("Conditional jmp on false to %d\n", opline->op2.opline_num);
31042 #endif
31043 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
31044 ZEND_VM_CONTINUE(); /* CHECK_ME */
31045 }
31046 }
31047
ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31048 static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31049 {
31050 USE_OPLINE
31051
31052 zval *val;
31053 int retval;
31054
31055 SAVE_OPLINE();
31056 val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31057
31058 if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
31059 retval = Z_LVAL_P(val);
31060 } else {
31061 retval = i_zend_is_true(val);
31062
31063 if (UNEXPECTED(EG(exception) != NULL)) {
31064 HANDLE_EXCEPTION();
31065 }
31066 }
31067 Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
31068 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
31069 if (!retval) {
31070 #if DEBUG_ZEND>=2
31071 printf("Conditional jmp to %d\n", opline->op2.opline_num);
31072 #endif
31073 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
31074 ZEND_VM_CONTINUE();
31075 }
31076 ZEND_VM_NEXT_OPCODE();
31077 }
31078
ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31079 static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31080 {
31081 USE_OPLINE
31082
31083 zval *val;
31084 int retval;
31085
31086 SAVE_OPLINE();
31087 val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31088
31089 if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
31090 retval = Z_LVAL_P(val);
31091 } else {
31092 retval = i_zend_is_true(val);
31093
31094 if (UNEXPECTED(EG(exception) != NULL)) {
31095 HANDLE_EXCEPTION();
31096 }
31097 }
31098 Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
31099 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
31100 if (retval) {
31101 #if DEBUG_ZEND>=2
31102 printf("Conditional jmp to %d\n", opline->op2.opline_num);
31103 #endif
31104 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
31105 ZEND_VM_CONTINUE();
31106 }
31107 ZEND_VM_NEXT_OPCODE();
31108 }
31109
ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31110 static int ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31111 {
31112 USE_OPLINE
31113 zval *retval_ptr;
31114
31115
31116 SAVE_OPLINE();
31117 retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31118
31119 if (!EG(return_value_ptr_ptr)) {
31120
31121 } else {
31122 if (IS_CV == IS_CONST ||
31123 IS_CV == IS_TMP_VAR ||
31124 PZVAL_IS_REF(retval_ptr)) {
31125 zval *ret;
31126
31127 ALLOC_ZVAL(ret);
31128 INIT_PZVAL_COPY(ret, retval_ptr);
31129 if (IS_CV != IS_TMP_VAR) {
31130 zval_copy_ctor(ret);
31131 }
31132 *EG(return_value_ptr_ptr) = ret;
31133
31134 } else if ((IS_CV == IS_CV || IS_CV == IS_VAR) &&
31135 retval_ptr == &EG(uninitialized_zval)) {
31136 zval *ret;
31137
31138 if (IS_CV == IS_VAR) {
31139 Z_DELREF_P(retval_ptr);
31140 }
31141 ALLOC_INIT_ZVAL(ret);
31142 *EG(return_value_ptr_ptr) = ret;
31143 } else {
31144 *EG(return_value_ptr_ptr) = retval_ptr;
31145 if (IS_CV == IS_CV) {
31146 Z_ADDREF_P(retval_ptr);
31147 }
31148 }
31149 }
31150 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31151 }
31152
ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31153 static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31154 {
31155 USE_OPLINE
31156 zval *retval_ptr;
31157 zval **retval_ptr_ptr;
31158
31159
31160 SAVE_OPLINE();
31161
31162 do {
31163 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR ||
31164 (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
31165 /* Not supposed to happen, but we'll allow it */
31166 zend_error(E_NOTICE, "Only variable references should be returned by reference");
31167
31168 retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31169 if (!EG(return_value_ptr_ptr)) {
31170 if (IS_CV == IS_TMP_VAR) {
31171
31172 }
31173 } else if (!0) { /* Not a temp var */
31174 zval *ret;
31175
31176 ALLOC_ZVAL(ret);
31177 INIT_PZVAL_COPY(ret, retval_ptr);
31178 zval_copy_ctor(ret);
31179 *EG(return_value_ptr_ptr) = ret;
31180 } else {
31181 zval *ret;
31182
31183 ALLOC_ZVAL(ret);
31184 INIT_PZVAL_COPY(ret, retval_ptr);
31185 *EG(return_value_ptr_ptr) = ret;
31186 }
31187 break;
31188 }
31189
31190 retval_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
31191
31192 if (IS_CV == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
31193 zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
31194 }
31195
31196 if (IS_CV == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
31197 if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
31198 EX_T(opline->op1.var).var.fcall_returned_reference) {
31199 } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
31200 zend_error(E_NOTICE, "Only variable references should be returned by reference");
31201 if (EG(return_value_ptr_ptr)) {
31202 zval *ret;
31203
31204 ALLOC_ZVAL(ret);
31205 INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
31206 zval_copy_ctor(ret);
31207 *EG(return_value_ptr_ptr) = ret;
31208 }
31209 break;
31210 }
31211 }
31212
31213 if (EG(return_value_ptr_ptr)) {
31214 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
31215 Z_ADDREF_PP(retval_ptr_ptr);
31216
31217 *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
31218 }
31219 } while (0);
31220
31221 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31222 }
31223
ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31224 static int ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31225 {
31226 USE_OPLINE
31227 zval *value;
31228 zval *exception;
31229
31230
31231 SAVE_OPLINE();
31232 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31233
31234 if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
31235 if (UNEXPECTED(EG(exception) != NULL)) {
31236 HANDLE_EXCEPTION();
31237 }
31238 zend_error_noreturn(E_ERROR, "Can only throw objects");
31239 }
31240
31241 zend_exception_save(TSRMLS_C);
31242 /* Not sure if a complete copy is what we want here */
31243 ALLOC_ZVAL(exception);
31244 INIT_PZVAL_COPY(exception, value);
31245 if (!0) {
31246 zval_copy_ctor(exception);
31247 }
31248
31249 zend_throw_exception_object(exception TSRMLS_CC);
31250 zend_exception_restore(TSRMLS_C);
31251
31252 HANDLE_EXCEPTION();
31253 }
31254
zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)31255 static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
31256 {
31257 USE_OPLINE
31258 zval *varptr;
31259
31260 varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31261
31262 if (varptr == &EG(uninitialized_zval)) {
31263 if (IS_CV == IS_VAR) {
31264 Z_DELREF_P(varptr);
31265 }
31266 ALLOC_INIT_ZVAL(varptr);
31267 } else if (PZVAL_IS_REF(varptr)) {
31268 if (IS_CV == IS_CV ||
31269 (IS_CV == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) {
31270 zval *original_var = varptr;
31271
31272 ALLOC_ZVAL(varptr);
31273 INIT_PZVAL_COPY(varptr, original_var);
31274 zval_copy_ctor(varptr);
31275
31276 } else {
31277 Z_UNSET_ISREF_P(varptr);
31278 }
31279 } else if (IS_CV == IS_CV) {
31280 Z_ADDREF_P(varptr);
31281 }
31282 zend_vm_stack_push(varptr TSRMLS_CC);
31283
31284 CHECK_EXCEPTION();
31285 ZEND_VM_NEXT_OPCODE();
31286 }
31287
ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31288 static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31289 {
31290 USE_OPLINE
31291
31292 zval *varptr;
31293
31294 SAVE_OPLINE();
31295 if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
31296 if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
31297 return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31298 }
31299 } else {
31300 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
31301 return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31302 }
31303 }
31304
31305 varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31306 if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
31307 EX_T(opline->op1.var).var.fcall_returned_reference) &&
31308 varptr != &EG(uninitialized_zval) &&
31309 (PZVAL_IS_REF(varptr) || Z_REFCOUNT_P(varptr) == 1)) {
31310 Z_SET_ISREF_P(varptr);
31311 if (IS_CV == IS_CV) {
31312 Z_ADDREF_P(varptr);
31313 }
31314 zend_vm_stack_push(varptr TSRMLS_CC);
31315 } else {
31316 zval *valptr;
31317
31318 if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
31319 !(opline->extended_value & ZEND_ARG_SEND_SILENT) :
31320 !ARG_MAY_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
31321 zend_error(E_STRICT, "Only variables should be passed by reference");
31322 }
31323 ALLOC_ZVAL(valptr);
31324 INIT_PZVAL_COPY(valptr, varptr);
31325 if (!0) {
31326 zval_copy_ctor(valptr);
31327 }
31328
31329 zend_vm_stack_push(valptr TSRMLS_CC);
31330 }
31331 CHECK_EXCEPTION();
31332 ZEND_VM_NEXT_OPCODE();
31333 }
31334
ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31335 static int ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31336 {
31337 USE_OPLINE
31338
31339 zval **varptr_ptr;
31340 zval *varptr;
31341
31342 SAVE_OPLINE();
31343 varptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
31344
31345 if (IS_CV == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) {
31346 zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
31347 }
31348
31349 if (IS_CV == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) {
31350 ALLOC_INIT_ZVAL(varptr);
31351 zend_vm_stack_push(varptr TSRMLS_CC);
31352 CHECK_EXCEPTION();
31353 ZEND_VM_NEXT_OPCODE();
31354 }
31355
31356 if (opline->extended_value == ZEND_DO_FCALL_BY_NAME &&
31357 EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
31358 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
31359 return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31360 }
31361 }
31362
31363 SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
31364 varptr = *varptr_ptr;
31365 Z_ADDREF_P(varptr);
31366 zend_vm_stack_push(varptr TSRMLS_CC);
31367
31368 CHECK_EXCEPTION();
31369 ZEND_VM_NEXT_OPCODE();
31370 }
31371
ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31372 static int ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31373 {
31374 USE_OPLINE
31375
31376 if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
31377 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
31378 return ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31379 }
31380 }
31381 SAVE_OPLINE();
31382 return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31383 }
31384
ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31385 static int ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31386 {
31387 USE_OPLINE
31388
31389 zval *retval = &EX_T(opline->result.var).tmp_var;
31390
31391 SAVE_OPLINE();
31392 /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
31393 ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC)));
31394
31395 CHECK_EXCEPTION();
31396 ZEND_VM_NEXT_OPCODE();
31397 }
31398
ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31399 static int ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31400 {
31401 USE_OPLINE
31402
31403 zval *obj;
31404 zend_class_entry *ce;
31405 zend_function *clone;
31406 zend_object_clone_obj_t clone_call;
31407
31408 SAVE_OPLINE();
31409 obj = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31410
31411 if (IS_CV == IS_CONST ||
31412 UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
31413 if (UNEXPECTED(EG(exception) != NULL)) {
31414 HANDLE_EXCEPTION();
31415 }
31416 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
31417 }
31418
31419 ce = Z_OBJCE_P(obj);
31420 clone = ce ? ce->clone : NULL;
31421 clone_call = Z_OBJ_HT_P(obj)->clone_obj;
31422 if (UNEXPECTED(clone_call == NULL)) {
31423 if (ce) {
31424 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
31425 } else {
31426 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
31427 }
31428 }
31429
31430 if (ce && clone) {
31431 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
31432 /* Ensure that if we're calling a private function, we're allowed to do so.
31433 */
31434 if (UNEXPECTED(ce != EG(scope))) {
31435 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
31436 }
31437 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
31438 /* Ensure that if we're calling a protected function, we're allowed to do so.
31439 */
31440 if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
31441 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
31442 }
31443 }
31444 }
31445
31446 if (EXPECTED(EG(exception) == NULL)) {
31447 zval *retval;
31448
31449 ALLOC_ZVAL(retval);
31450 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
31451 Z_TYPE_P(retval) = IS_OBJECT;
31452 Z_SET_REFCOUNT_P(retval, 1);
31453 Z_SET_ISREF_P(retval);
31454 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
31455 zval_ptr_dtor(&retval);
31456 } else {
31457 EX_T(opline->result.var).var.ptr = retval;
31458 }
31459 }
31460
31461 CHECK_EXCEPTION();
31462 ZEND_VM_NEXT_OPCODE();
31463 }
31464
ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31465 static int ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31466 {
31467 USE_OPLINE
31468
31469 zval *expr;
31470 zval *result = &EX_T(opline->result.var).tmp_var;
31471
31472 SAVE_OPLINE();
31473 expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31474
31475 if (opline->extended_value != IS_STRING) {
31476 ZVAL_COPY_VALUE(result, expr);
31477 if (!0) {
31478 zendi_zval_copy_ctor(*result);
31479 }
31480 }
31481 switch (opline->extended_value) {
31482 case IS_NULL:
31483 convert_to_null(result);
31484 break;
31485 case IS_BOOL:
31486 convert_to_boolean(result);
31487 break;
31488 case IS_LONG:
31489 convert_to_long(result);
31490 break;
31491 case IS_DOUBLE:
31492 convert_to_double(result);
31493 break;
31494 case IS_STRING: {
31495 zval var_copy;
31496 int use_copy;
31497
31498 zend_make_printable_zval(expr, &var_copy, &use_copy);
31499 if (use_copy) {
31500 ZVAL_COPY_VALUE(result, &var_copy);
31501 if (0) {
31502
31503 }
31504 } else {
31505 ZVAL_COPY_VALUE(result, expr);
31506 if (!0) {
31507 zendi_zval_copy_ctor(*result);
31508 }
31509 }
31510 break;
31511 }
31512 case IS_ARRAY:
31513 convert_to_array(result);
31514 break;
31515 case IS_OBJECT:
31516 convert_to_object(result);
31517 break;
31518 }
31519
31520 CHECK_EXCEPTION();
31521 ZEND_VM_NEXT_OPCODE();
31522 }
31523
ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31524 static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31525 {
31526 USE_OPLINE
31527 zend_op_array *new_op_array=NULL;
31528
31529 zval *inc_filename;
31530 zval *tmp_inc_filename = NULL;
31531 zend_bool failure_retval=0;
31532
31533 SAVE_OPLINE();
31534 inc_filename = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31535
31536 if (inc_filename->type!=IS_STRING) {
31537 MAKE_STD_ZVAL(tmp_inc_filename);
31538 ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
31539 zval_copy_ctor(tmp_inc_filename);
31540 convert_to_string(tmp_inc_filename);
31541 inc_filename = tmp_inc_filename;
31542 }
31543
31544 if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
31545 if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
31546 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
31547 } else {
31548 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
31549 }
31550 } else {
31551 switch (opline->extended_value) {
31552 case ZEND_INCLUDE_ONCE:
31553 case ZEND_REQUIRE_ONCE: {
31554 zend_file_handle file_handle;
31555 char *resolved_path;
31556
31557 resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
31558 if (resolved_path) {
31559 failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
31560 } else {
31561 resolved_path = Z_STRVAL_P(inc_filename);
31562 }
31563
31564 if (failure_retval) {
31565 /* do nothing, file already included */
31566 } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
31567
31568 if (!file_handle.opened_path) {
31569 file_handle.opened_path = estrdup(resolved_path);
31570 }
31571
31572 if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
31573 new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
31574 zend_destroy_file_handle(&file_handle TSRMLS_CC);
31575 } else {
31576 zend_file_handle_dtor(&file_handle TSRMLS_CC);
31577 failure_retval=1;
31578 }
31579 } else {
31580 if (opline->extended_value == ZEND_INCLUDE_ONCE) {
31581 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
31582 } else {
31583 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
31584 }
31585 }
31586 if (resolved_path != Z_STRVAL_P(inc_filename)) {
31587 efree(resolved_path);
31588 }
31589 }
31590 break;
31591 case ZEND_INCLUDE:
31592 case ZEND_REQUIRE:
31593 new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC);
31594 break;
31595 case ZEND_EVAL: {
31596 char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
31597
31598 new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
31599 efree(eval_desc);
31600 }
31601 break;
31602 EMPTY_SWITCH_DEFAULT_CASE()
31603 }
31604 }
31605 if (tmp_inc_filename) {
31606 zval_ptr_dtor(&tmp_inc_filename);
31607 }
31608
31609 if (UNEXPECTED(EG(exception) != NULL)) {
31610 HANDLE_EXCEPTION();
31611 } else if (EXPECTED(new_op_array != NULL)) {
31612 EX(original_return_value) = EG(return_value_ptr_ptr);
31613 EG(active_op_array) = new_op_array;
31614 if (RETURN_VALUE_USED(opline)) {
31615 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
31616 EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
31617 } else {
31618 EG(return_value_ptr_ptr) = NULL;
31619 }
31620
31621 EX(function_state).function = (zend_function *) new_op_array;
31622 EX(object) = NULL;
31623
31624 if (!EG(active_symbol_table)) {
31625 zend_rebuild_symbol_table(TSRMLS_C);
31626 }
31627
31628 if (EXPECTED(zend_execute_ex == execute_ex)) {
31629 ZEND_VM_ENTER();
31630 } else {
31631 zend_execute(new_op_array TSRMLS_CC);
31632 }
31633
31634 EX(function_state).function = (zend_function *) EX(op_array);
31635
31636 EG(opline_ptr) = &EX(opline);
31637 EG(active_op_array) = EX(op_array);
31638 EG(return_value_ptr_ptr) = EX(original_return_value);
31639 destroy_op_array(new_op_array TSRMLS_CC);
31640 efree(new_op_array);
31641 if (UNEXPECTED(EG(exception) != NULL)) {
31642 zend_throw_exception_internal(NULL TSRMLS_CC);
31643 HANDLE_EXCEPTION();
31644 }
31645
31646 } else if (RETURN_VALUE_USED(opline)) {
31647 zval *retval;
31648
31649 ALLOC_ZVAL(retval);
31650 ZVAL_BOOL(retval, failure_retval);
31651 INIT_PZVAL(retval);
31652 EX_T(opline->result.var).var.ptr = retval;
31653 }
31654 ZEND_VM_NEXT_OPCODE();
31655 }
31656
ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31657 static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31658 {
31659 USE_OPLINE
31660
31661 zval *array_ptr, **array_ptr_ptr;
31662 HashTable *fe_ht;
31663 zend_object_iterator *iter = NULL;
31664 zend_class_entry *ce = NULL;
31665 zend_bool is_empty = 0;
31666
31667 SAVE_OPLINE();
31668
31669 if ((IS_CV == IS_CV || IS_CV == IS_VAR) &&
31670 (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
31671 array_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31672 if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
31673 MAKE_STD_ZVAL(array_ptr);
31674 ZVAL_NULL(array_ptr);
31675 } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
31676 if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
31677 zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
31678 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
31679 }
31680
31681 ce = Z_OBJCE_PP(array_ptr_ptr);
31682 if (!ce || ce->get_iterator == NULL) {
31683 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
31684 Z_ADDREF_PP(array_ptr_ptr);
31685 }
31686 array_ptr = *array_ptr_ptr;
31687 } else {
31688 if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
31689 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
31690 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
31691 Z_SET_ISREF_PP(array_ptr_ptr);
31692 }
31693 }
31694 array_ptr = *array_ptr_ptr;
31695 Z_ADDREF_P(array_ptr);
31696 }
31697 } else {
31698 array_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31699 if (0) { /* IS_TMP_VAR */
31700 zval *tmp;
31701
31702 ALLOC_ZVAL(tmp);
31703 INIT_PZVAL_COPY(tmp, array_ptr);
31704 array_ptr = tmp;
31705 if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
31706 ce = Z_OBJCE_P(array_ptr);
31707 if (ce && ce->get_iterator) {
31708 Z_DELREF_P(array_ptr);
31709 }
31710 }
31711 } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
31712 ce = Z_OBJCE_P(array_ptr);
31713 if (!ce || !ce->get_iterator) {
31714 if (IS_CV == IS_CV) {
31715 Z_ADDREF_P(array_ptr);
31716 }
31717 }
31718 } else if (IS_CV == IS_CONST ||
31719 (IS_CV == IS_CV &&
31720 !Z_ISREF_P(array_ptr) &&
31721 Z_REFCOUNT_P(array_ptr) > 1) ||
31722 (IS_CV == IS_VAR &&
31723 !Z_ISREF_P(array_ptr) &&
31724 Z_REFCOUNT_P(array_ptr) > 2)) {
31725 zval *tmp;
31726
31727 if (IS_CV == IS_VAR) {
31728 Z_DELREF_P(array_ptr);
31729 }
31730 ALLOC_ZVAL(tmp);
31731 INIT_PZVAL_COPY(tmp, array_ptr);
31732 zval_copy_ctor(tmp);
31733 array_ptr = tmp;
31734 } else if (IS_CV == IS_CV) {
31735 Z_ADDREF_P(array_ptr);
31736 }
31737 }
31738
31739 if (ce && ce->get_iterator) {
31740 iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
31741
31742 if (IS_CV == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
31743
31744 }
31745 if (iter && EXPECTED(EG(exception) == NULL)) {
31746 array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
31747 } else {
31748 if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
31749
31750 }
31751 if (!EG(exception)) {
31752 zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
31753 }
31754 zend_throw_exception_internal(NULL TSRMLS_CC);
31755 HANDLE_EXCEPTION();
31756 }
31757 }
31758
31759 EX_T(opline->result.var).fe.ptr = array_ptr;
31760
31761 if (iter) {
31762 iter->index = 0;
31763 if (iter->funcs->rewind) {
31764 iter->funcs->rewind(iter TSRMLS_CC);
31765 if (UNEXPECTED(EG(exception) != NULL)) {
31766 zval_ptr_dtor(&array_ptr);
31767 if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
31768
31769 }
31770 HANDLE_EXCEPTION();
31771 }
31772 }
31773 is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
31774 if (UNEXPECTED(EG(exception) != NULL)) {
31775 zval_ptr_dtor(&array_ptr);
31776 if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
31777
31778 }
31779 HANDLE_EXCEPTION();
31780 }
31781 iter->index = -1; /* will be set to 0 before using next handler */
31782 } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
31783 zend_hash_internal_pointer_reset(fe_ht);
31784 if (ce) {
31785 zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
31786 while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
31787 char *str_key;
31788 uint str_key_len;
31789 ulong int_key;
31790 zend_uchar key_type;
31791
31792 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
31793 if (key_type != HASH_KEY_NON_EXISTENT &&
31794 (key_type == HASH_KEY_IS_LONG ||
31795 zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
31796 break;
31797 }
31798 zend_hash_move_forward(fe_ht);
31799 }
31800 }
31801 is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
31802 zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
31803 } else {
31804 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
31805 is_empty = 1;
31806 }
31807
31808 if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
31809
31810 }
31811 if (is_empty) {
31812 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
31813 } else {
31814 CHECK_EXCEPTION();
31815 ZEND_VM_NEXT_OPCODE();
31816 }
31817 }
31818
ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31819 static int ZEND_FASTCALL ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31820 {
31821 #if 0 || (IS_CV != IS_UNUSED)
31822 USE_OPLINE
31823
31824 SAVE_OPLINE();
31825 if (IS_CV != IS_UNUSED) {
31826
31827 zval *ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31828
31829 if (Z_TYPE_P(ptr) == IS_LONG) {
31830 EG(exit_status) = Z_LVAL_P(ptr);
31831 } else {
31832 zend_print_variable(ptr);
31833 }
31834
31835 }
31836 #endif
31837 zend_bailout();
31838 ZEND_VM_NEXT_OPCODE(); /* Never reached */
31839 }
31840
ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31841 static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31842 {
31843 USE_OPLINE
31844
31845 zval *value;
31846
31847 SAVE_OPLINE();
31848 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31849
31850 if (i_zend_is_true(value)) {
31851 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
31852 if (!0) {
31853 zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
31854 }
31855
31856 #if DEBUG_ZEND>=2
31857 printf("Conditional jmp to %d\n", opline->op2.opline_num);
31858 #endif
31859 ZEND_VM_JMP(opline->op2.jmp_addr);
31860 }
31861
31862 CHECK_EXCEPTION();
31863 ZEND_VM_NEXT_OPCODE();
31864 }
31865
ZEND_JMP_SET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31866 static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31867 {
31868 USE_OPLINE
31869
31870 zval *value, *ret;
31871
31872 SAVE_OPLINE();
31873 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31874
31875 if (i_zend_is_true(value)) {
31876 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
31877 Z_ADDREF_P(value);
31878 EX_T(opline->result.var).var.ptr = value;
31879 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
31880 } else {
31881 ALLOC_ZVAL(ret);
31882 INIT_PZVAL_COPY(ret, value);
31883 EX_T(opline->result.var).var.ptr = ret;
31884 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
31885 if (!0) {
31886 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
31887 }
31888 }
31889
31890 #if DEBUG_ZEND>=2
31891 printf("Conditional jmp to %d\n", opline->op2.opline_num);
31892 #endif
31893 ZEND_VM_JMP(opline->op2.jmp_addr);
31894 }
31895
31896 CHECK_EXCEPTION();
31897 ZEND_VM_NEXT_OPCODE();
31898 }
31899
ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31900 static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31901 {
31902 USE_OPLINE
31903
31904 zval *value;
31905
31906 SAVE_OPLINE();
31907 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31908
31909 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
31910 if (!0) {
31911 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
31912 }
31913
31914 CHECK_EXCEPTION();
31915 ZEND_VM_NEXT_OPCODE();
31916 }
31917
ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31918 static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31919 {
31920 USE_OPLINE
31921
31922 zval *value, *ret;
31923
31924 SAVE_OPLINE();
31925 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31926
31927 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
31928 Z_ADDREF_P(value);
31929 EX_T(opline->result.var).var.ptr = value;
31930 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
31931 } else {
31932 ALLOC_ZVAL(ret);
31933 INIT_PZVAL_COPY(ret, value);
31934 EX_T(opline->result.var).var.ptr = ret;
31935 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
31936 if (!0) {
31937 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
31938 }
31939 }
31940
31941 CHECK_EXCEPTION();
31942 ZEND_VM_NEXT_OPCODE();
31943 }
31944
ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31945 static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31946 {
31947 USE_OPLINE
31948
31949 zval *expr;
31950 zend_bool result;
31951
31952 SAVE_OPLINE();
31953 expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31954
31955 if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
31956 result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
31957 } else {
31958 result = 0;
31959 }
31960 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
31961
31962 CHECK_EXCEPTION();
31963 ZEND_VM_NEXT_OPCODE();
31964 }
31965
ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31966 static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31967 {
31968 USE_OPLINE
31969
31970
31971 SAVE_OPLINE();
31972 fast_add_function(&EX_T(opline->result.var).tmp_var,
31973 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31974 opline->op2.zv TSRMLS_CC);
31975
31976
31977 CHECK_EXCEPTION();
31978 ZEND_VM_NEXT_OPCODE();
31979 }
31980
ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31981 static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31982 {
31983 USE_OPLINE
31984
31985
31986 SAVE_OPLINE();
31987 fast_sub_function(&EX_T(opline->result.var).tmp_var,
31988 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31989 opline->op2.zv TSRMLS_CC);
31990
31991
31992 CHECK_EXCEPTION();
31993 ZEND_VM_NEXT_OPCODE();
31994 }
31995
ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31996 static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31997 {
31998 USE_OPLINE
31999
32000
32001 SAVE_OPLINE();
32002 fast_mul_function(&EX_T(opline->result.var).tmp_var,
32003 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32004 opline->op2.zv TSRMLS_CC);
32005
32006
32007 CHECK_EXCEPTION();
32008 ZEND_VM_NEXT_OPCODE();
32009 }
32010
ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32011 static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32012 {
32013 USE_OPLINE
32014
32015
32016 SAVE_OPLINE();
32017 fast_div_function(&EX_T(opline->result.var).tmp_var,
32018 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32019 opline->op2.zv TSRMLS_CC);
32020
32021
32022 CHECK_EXCEPTION();
32023 ZEND_VM_NEXT_OPCODE();
32024 }
32025
ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32026 static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32027 {
32028 USE_OPLINE
32029
32030
32031 SAVE_OPLINE();
32032 fast_mod_function(&EX_T(opline->result.var).tmp_var,
32033 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32034 opline->op2.zv TSRMLS_CC);
32035
32036
32037 CHECK_EXCEPTION();
32038 ZEND_VM_NEXT_OPCODE();
32039 }
32040
ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32041 static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32042 {
32043 USE_OPLINE
32044
32045
32046 SAVE_OPLINE();
32047 shift_left_function(&EX_T(opline->result.var).tmp_var,
32048 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32049 opline->op2.zv TSRMLS_CC);
32050
32051
32052 CHECK_EXCEPTION();
32053 ZEND_VM_NEXT_OPCODE();
32054 }
32055
ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32056 static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32057 {
32058 USE_OPLINE
32059
32060
32061 SAVE_OPLINE();
32062 shift_right_function(&EX_T(opline->result.var).tmp_var,
32063 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32064 opline->op2.zv TSRMLS_CC);
32065
32066
32067 CHECK_EXCEPTION();
32068 ZEND_VM_NEXT_OPCODE();
32069 }
32070
ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32071 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32072 {
32073 USE_OPLINE
32074
32075
32076 SAVE_OPLINE();
32077 concat_function(&EX_T(opline->result.var).tmp_var,
32078 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32079 opline->op2.zv TSRMLS_CC);
32080
32081
32082 CHECK_EXCEPTION();
32083 ZEND_VM_NEXT_OPCODE();
32084 }
32085
ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32086 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32087 {
32088 USE_OPLINE
32089
32090
32091 SAVE_OPLINE();
32092 is_identical_function(&EX_T(opline->result.var).tmp_var,
32093 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32094 opline->op2.zv TSRMLS_CC);
32095
32096
32097 CHECK_EXCEPTION();
32098 ZEND_VM_NEXT_OPCODE();
32099 }
32100
ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32101 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32102 {
32103 USE_OPLINE
32104
32105 zval *result = &EX_T(opline->result.var).tmp_var;
32106
32107 SAVE_OPLINE();
32108 is_identical_function(result,
32109 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32110 opline->op2.zv TSRMLS_CC);
32111 Z_LVAL_P(result) = !Z_LVAL_P(result);
32112
32113
32114 CHECK_EXCEPTION();
32115 ZEND_VM_NEXT_OPCODE();
32116 }
32117
ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32118 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32119 {
32120 USE_OPLINE
32121
32122 zval *result = &EX_T(opline->result.var).tmp_var;
32123
32124 SAVE_OPLINE();
32125 ZVAL_BOOL(result, fast_equal_function(result,
32126 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32127 opline->op2.zv TSRMLS_CC));
32128
32129
32130 CHECK_EXCEPTION();
32131 ZEND_VM_NEXT_OPCODE();
32132 }
32133
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32134 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32135 {
32136 USE_OPLINE
32137
32138 zval *result = &EX_T(opline->result.var).tmp_var;
32139
32140 SAVE_OPLINE();
32141 ZVAL_BOOL(result, fast_not_equal_function(result,
32142 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32143 opline->op2.zv TSRMLS_CC));
32144
32145
32146 CHECK_EXCEPTION();
32147 ZEND_VM_NEXT_OPCODE();
32148 }
32149
ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32150 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32151 {
32152 USE_OPLINE
32153
32154 zval *result = &EX_T(opline->result.var).tmp_var;
32155
32156 SAVE_OPLINE();
32157 ZVAL_BOOL(result, fast_is_smaller_function(result,
32158 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32159 opline->op2.zv TSRMLS_CC));
32160
32161
32162 CHECK_EXCEPTION();
32163 ZEND_VM_NEXT_OPCODE();
32164 }
32165
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32166 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32167 {
32168 USE_OPLINE
32169
32170 zval *result = &EX_T(opline->result.var).tmp_var;
32171
32172 SAVE_OPLINE();
32173 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
32174 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32175 opline->op2.zv TSRMLS_CC));
32176
32177
32178 CHECK_EXCEPTION();
32179 ZEND_VM_NEXT_OPCODE();
32180 }
32181
ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32182 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32183 {
32184 USE_OPLINE
32185
32186
32187 SAVE_OPLINE();
32188 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
32189 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32190 opline->op2.zv TSRMLS_CC);
32191
32192
32193 CHECK_EXCEPTION();
32194 ZEND_VM_NEXT_OPCODE();
32195 }
32196
ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32197 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32198 {
32199 USE_OPLINE
32200
32201
32202 SAVE_OPLINE();
32203 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
32204 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32205 opline->op2.zv TSRMLS_CC);
32206
32207
32208 CHECK_EXCEPTION();
32209 ZEND_VM_NEXT_OPCODE();
32210 }
32211
ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32212 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32213 {
32214 USE_OPLINE
32215
32216
32217 SAVE_OPLINE();
32218 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
32219 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32220 opline->op2.zv TSRMLS_CC);
32221
32222
32223 CHECK_EXCEPTION();
32224 ZEND_VM_NEXT_OPCODE();
32225 }
32226
ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32227 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32228 {
32229 USE_OPLINE
32230
32231
32232 SAVE_OPLINE();
32233 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
32234 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32235 opline->op2.zv TSRMLS_CC);
32236
32237
32238 CHECK_EXCEPTION();
32239 ZEND_VM_NEXT_OPCODE();
32240 }
32241
zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)32242 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
32243 {
32244 USE_OPLINE
32245 zend_free_op free_op_data1;
32246 zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32247 zval *object;
32248 zval *property = opline->op2.zv;
32249 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
32250 int have_get_ptr = 0;
32251
32252 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
32253 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
32254 }
32255
32256 make_real_object(object_ptr TSRMLS_CC);
32257 object = *object_ptr;
32258
32259 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32260 zend_error(E_WARNING, "Attempt to assign property of non-object");
32261
32262 FREE_OP(free_op_data1);
32263
32264 if (RETURN_VALUE_USED(opline)) {
32265 PZVAL_LOCK(&EG(uninitialized_zval));
32266 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
32267 }
32268 } else {
32269 /* here we are sure we are dealing with an object */
32270 if (0) {
32271 MAKE_REAL_ZVAL_PTR(property);
32272 }
32273
32274 /* here property is a string */
32275 if (opline->extended_value == ZEND_ASSIGN_OBJ
32276 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
32277 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32278 if (zptr != NULL) { /* NULL means no success in getting PTR */
32279 have_get_ptr = 1;
32280 if (UNEXPECTED(*zptr == &EG(error_zval))) {
32281 if (RETURN_VALUE_USED(opline)) {
32282 PZVAL_LOCK(&EG(uninitialized_zval));
32283 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
32284 }
32285 } else {
32286 SEPARATE_ZVAL_IF_NOT_REF(zptr);
32287
32288 binary_op(*zptr, *zptr, value TSRMLS_CC);
32289 if (RETURN_VALUE_USED(opline)) {
32290 PZVAL_LOCK(*zptr);
32291 EX_T(opline->result.var).var.ptr = *zptr;
32292 }
32293 }
32294 }
32295 }
32296
32297 if (!have_get_ptr) {
32298 zval *z = NULL;
32299
32300 Z_ADDREF_P(object);
32301 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
32302 if (Z_OBJ_HT_P(object)->read_property) {
32303 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32304 }
32305 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
32306 if (Z_OBJ_HT_P(object)->read_dimension) {
32307 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
32308 }
32309 }
32310 if (z) {
32311 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
32312 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
32313
32314 if (Z_REFCOUNT_P(z) == 0) {
32315 GC_REMOVE_ZVAL_FROM_BUFFER(z);
32316 zval_dtor(z);
32317 FREE_ZVAL(z);
32318 }
32319 z = value;
32320 }
32321 Z_ADDREF_P(z);
32322 SEPARATE_ZVAL_IF_NOT_REF(&z);
32323 binary_op(z, z, value TSRMLS_CC);
32324 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
32325 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32326 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
32327 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
32328 }
32329 if (RETURN_VALUE_USED(opline)) {
32330 PZVAL_LOCK(z);
32331 EX_T(opline->result.var).var.ptr = z;
32332 }
32333 zval_ptr_dtor(&z);
32334 } else {
32335 zend_error(E_WARNING, "Attempt to assign property of non-object");
32336 if (RETURN_VALUE_USED(opline)) {
32337 PZVAL_LOCK(&EG(uninitialized_zval));
32338 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
32339 }
32340 }
32341 zval_ptr_dtor(&object);
32342 }
32343
32344 if (0) {
32345 zval_ptr_dtor(&property);
32346 } else {
32347
32348 }
32349 FREE_OP(free_op_data1);
32350 }
32351
32352 /* assign_obj has two opcodes! */
32353 CHECK_EXCEPTION();
32354 ZEND_VM_INC_OPCODE();
32355 ZEND_VM_NEXT_OPCODE();
32356 }
32357
zend_binary_assign_op_helper_SPEC_CV_CONST(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)32358 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
32359 {
32360 USE_OPLINE
32361 zend_free_op free_op_data2, free_op_data1;
32362 zval **var_ptr;
32363 zval *value;
32364
32365 SAVE_OPLINE();
32366 switch (opline->extended_value) {
32367 case ZEND_ASSIGN_OBJ:
32368 return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32369 break;
32370 case ZEND_ASSIGN_DIM: {
32371 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32372
32373 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32374 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
32375 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
32376 if (IS_CV == IS_VAR && !0) {
32377 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
32378 }
32379 return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32380 } else {
32381 zval *dim = opline->op2.zv;
32382
32383 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC);
32384 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
32385 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
32386 }
32387 }
32388 break;
32389 default:
32390 value = opline->op2.zv;
32391 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32392 /* do nothing */
32393 break;
32394 }
32395
32396 if (UNEXPECTED(var_ptr == NULL)) {
32397 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
32398 }
32399
32400 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
32401 if (RETURN_VALUE_USED(opline)) {
32402 PZVAL_LOCK(&EG(uninitialized_zval));
32403 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
32404 }
32405
32406
32407 CHECK_EXCEPTION();
32408 if (opline->extended_value == ZEND_ASSIGN_DIM) {
32409 ZEND_VM_INC_OPCODE();
32410 }
32411 ZEND_VM_NEXT_OPCODE();
32412 }
32413
32414 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
32415
32416 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
32417 && Z_OBJ_HANDLER_PP(var_ptr, get)
32418 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
32419 /* proxy object */
32420 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
32421 Z_ADDREF_P(objval);
32422 binary_op(objval, objval, value TSRMLS_CC);
32423 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
32424 zval_ptr_dtor(&objval);
32425 } else {
32426 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
32427 }
32428
32429 if (RETURN_VALUE_USED(opline)) {
32430 PZVAL_LOCK(*var_ptr);
32431 EX_T(opline->result.var).var.ptr = *var_ptr;
32432 }
32433
32434 if (opline->extended_value == ZEND_ASSIGN_DIM) {
32435 FREE_OP(free_op_data1);
32436 FREE_OP_VAR_PTR(free_op_data2);
32437
32438 CHECK_EXCEPTION();
32439 ZEND_VM_INC_OPCODE();
32440 } else {
32441
32442 CHECK_EXCEPTION();
32443 }
32444 ZEND_VM_NEXT_OPCODE();
32445 }
32446
ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32447 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32448 {
32449 return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32450 }
32451
ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32452 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32453 {
32454 return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32455 }
32456
ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32457 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32458 {
32459 return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32460 }
32461
ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32462 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32463 {
32464 return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32465 }
32466
ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32467 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32468 {
32469 return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32470 }
32471
ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32472 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32473 {
32474 return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32475 }
32476
ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32477 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32478 {
32479 return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32480 }
32481
ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32482 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32483 {
32484 return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32485 }
32486
ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32487 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32488 {
32489 return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32490 }
32491
ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32492 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32493 {
32494 return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32495 }
32496
ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32497 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32498 {
32499 return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32500 }
32501
zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)32502 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
32503 {
32504 USE_OPLINE
32505
32506 zval **object_ptr;
32507 zval *object;
32508 zval *property;
32509 zval **retval;
32510 int have_get_ptr = 0;
32511
32512 SAVE_OPLINE();
32513 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32514 property = opline->op2.zv;
32515 retval = &EX_T(opline->result.var).var.ptr;
32516
32517 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
32518 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
32519 }
32520
32521 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
32522 object = *object_ptr;
32523
32524 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32525 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
32526
32527 if (RETURN_VALUE_USED(opline)) {
32528 PZVAL_LOCK(&EG(uninitialized_zval));
32529 *retval = &EG(uninitialized_zval);
32530 }
32531
32532 CHECK_EXCEPTION();
32533 ZEND_VM_NEXT_OPCODE();
32534 }
32535
32536 /* here we are sure we are dealing with an object */
32537
32538 if (0) {
32539 MAKE_REAL_ZVAL_PTR(property);
32540 }
32541
32542 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
32543 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32544 if (zptr != NULL) { /* NULL means no success in getting PTR */
32545 have_get_ptr = 1;
32546 if (UNEXPECTED(*zptr == &EG(error_zval))) {
32547 if (RETURN_VALUE_USED(opline)) {
32548 PZVAL_LOCK(&EG(uninitialized_zval));
32549 *retval = &EG(uninitialized_zval);
32550 }
32551 } else {
32552 SEPARATE_ZVAL_IF_NOT_REF(zptr);
32553
32554 incdec_op(*zptr);
32555 if (RETURN_VALUE_USED(opline)) {
32556 *retval = *zptr;
32557 PZVAL_LOCK(*retval);
32558 }
32559 }
32560 }
32561 }
32562
32563 if (!have_get_ptr) {
32564 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
32565 zval *z;
32566
32567 Z_ADDREF_P(object);
32568 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32569
32570 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
32571 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
32572
32573 if (Z_REFCOUNT_P(z) == 0) {
32574 GC_REMOVE_ZVAL_FROM_BUFFER(z);
32575 zval_dtor(z);
32576 FREE_ZVAL(z);
32577 }
32578 z = value;
32579 }
32580 Z_ADDREF_P(z);
32581 SEPARATE_ZVAL_IF_NOT_REF(&z);
32582 incdec_op(z);
32583 *retval = z;
32584 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32585 zval_ptr_dtor(&object);
32586 SELECTIVE_PZVAL_LOCK(*retval, opline);
32587 zval_ptr_dtor(&z);
32588 } else {
32589 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
32590 if (RETURN_VALUE_USED(opline)) {
32591 PZVAL_LOCK(&EG(uninitialized_zval));
32592 *retval = &EG(uninitialized_zval);
32593 }
32594 }
32595 }
32596
32597 if (0) {
32598 zval_ptr_dtor(&property);
32599 } else {
32600
32601 }
32602
32603 CHECK_EXCEPTION();
32604 ZEND_VM_NEXT_OPCODE();
32605 }
32606
ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32607 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32608 {
32609 return zend_pre_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32610 }
32611
ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32612 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32613 {
32614 return zend_pre_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32615 }
32616
zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)32617 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
32618 {
32619 USE_OPLINE
32620
32621 zval **object_ptr;
32622 zval *object;
32623 zval *property;
32624 zval *retval;
32625 int have_get_ptr = 0;
32626
32627 SAVE_OPLINE();
32628 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32629 property = opline->op2.zv;
32630 retval = &EX_T(opline->result.var).tmp_var;
32631
32632 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
32633 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
32634 }
32635
32636 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
32637 object = *object_ptr;
32638
32639 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32640 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
32641
32642 ZVAL_NULL(retval);
32643
32644 CHECK_EXCEPTION();
32645 ZEND_VM_NEXT_OPCODE();
32646 }
32647
32648 /* here we are sure we are dealing with an object */
32649
32650 if (0) {
32651 MAKE_REAL_ZVAL_PTR(property);
32652 }
32653
32654 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
32655 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32656 if (zptr != NULL) { /* NULL means no success in getting PTR */
32657 have_get_ptr = 1;
32658 if (UNEXPECTED(*zptr == &EG(error_zval))) {
32659 ZVAL_NULL(retval);
32660 } else {
32661 SEPARATE_ZVAL_IF_NOT_REF(zptr);
32662
32663 ZVAL_COPY_VALUE(retval, *zptr);
32664 zendi_zval_copy_ctor(*retval);
32665
32666 incdec_op(*zptr);
32667 }
32668 }
32669 }
32670
32671 if (!have_get_ptr) {
32672 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
32673 zval *z, *z_copy;
32674
32675 Z_ADDREF_P(object);
32676 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32677 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
32678 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
32679
32680 if (Z_REFCOUNT_P(z) == 0) {
32681 GC_REMOVE_ZVAL_FROM_BUFFER(z);
32682 zval_dtor(z);
32683 FREE_ZVAL(z);
32684 }
32685 z = value;
32686 }
32687 ZVAL_COPY_VALUE(retval, z);
32688 zendi_zval_copy_ctor(*retval);
32689 ALLOC_ZVAL(z_copy);
32690 INIT_PZVAL_COPY(z_copy, z);
32691 zendi_zval_copy_ctor(*z_copy);
32692 incdec_op(z_copy);
32693 Z_ADDREF_P(z);
32694 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32695 zval_ptr_dtor(&object);
32696 zval_ptr_dtor(&z_copy);
32697 zval_ptr_dtor(&z);
32698 } else {
32699 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
32700 ZVAL_NULL(retval);
32701 }
32702 }
32703
32704 if (0) {
32705 zval_ptr_dtor(&property);
32706 } else {
32707
32708 }
32709
32710 CHECK_EXCEPTION();
32711 ZEND_VM_NEXT_OPCODE();
32712 }
32713
ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32714 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32715 {
32716 return zend_post_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32717 }
32718
ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32719 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32720 {
32721 return zend_post_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32722 }
32723
zend_fetch_var_address_helper_SPEC_CV_CONST(int type,ZEND_OPCODE_HANDLER_ARGS)32724 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
32725 {
32726 USE_OPLINE
32727 zend_free_op free_op1;
32728 zval *varname;
32729 zval **retval;
32730 zval tmp_varname;
32731 HashTable *target_symbol_table;
32732 ulong hash_value;
32733
32734 SAVE_OPLINE();
32735 varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
32736
32737 if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
32738 ZVAL_COPY_VALUE(&tmp_varname, varname);
32739 zval_copy_ctor(&tmp_varname);
32740 Z_SET_REFCOUNT(tmp_varname, 1);
32741 Z_UNSET_ISREF(tmp_varname);
32742 convert_to_string(&tmp_varname);
32743 varname = &tmp_varname;
32744 }
32745
32746 if (IS_CONST != IS_UNUSED) {
32747 zend_class_entry *ce;
32748
32749 if (IS_CONST == IS_CONST) {
32750 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
32751 ce = CACHED_PTR(opline->op2.literal->cache_slot);
32752 } else {
32753 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
32754 if (UNEXPECTED(ce == NULL)) {
32755 if (IS_CV != IS_CONST && varname == &tmp_varname) {
32756 zval_dtor(&tmp_varname);
32757 }
32758
32759 CHECK_EXCEPTION();
32760 ZEND_VM_NEXT_OPCODE();
32761 }
32762 CACHE_PTR(opline->op2.literal->cache_slot, ce);
32763 }
32764 } else {
32765 ce = EX_T(opline->op2.var).class_entry;
32766 }
32767 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
32768
32769 } else {
32770 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
32771 /*
32772 if (!target_symbol_table) {
32773 CHECK_EXCEPTION();
32774 ZEND_VM_NEXT_OPCODE();
32775 }
32776 */
32777 if (IS_CV == IS_CONST) {
32778 hash_value = Z_HASH_P(varname);
32779 } else {
32780 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
32781 }
32782
32783 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
32784 switch (type) {
32785 case BP_VAR_R:
32786 case BP_VAR_UNSET:
32787 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
32788 /* break missing intentionally */
32789 case BP_VAR_IS:
32790 retval = &EG(uninitialized_zval_ptr);
32791 break;
32792 case BP_VAR_RW:
32793 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
32794 /* break missing intentionally */
32795 case BP_VAR_W:
32796 Z_ADDREF_P(&EG(uninitialized_zval));
32797 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
32798 break;
32799 EMPTY_SWITCH_DEFAULT_CASE()
32800 }
32801 }
32802 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
32803 case ZEND_FETCH_GLOBAL:
32804 if (IS_CV != IS_TMP_VAR) {
32805
32806 }
32807 break;
32808 case ZEND_FETCH_LOCAL:
32809
32810 break;
32811 case ZEND_FETCH_STATIC:
32812 zval_update_constant(retval, 1 TSRMLS_CC);
32813 break;
32814 case ZEND_FETCH_GLOBAL_LOCK:
32815 if (IS_CV == IS_VAR && !free_op1.var) {
32816 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
32817 }
32818 break;
32819 }
32820 }
32821
32822
32823 if (IS_CV != IS_CONST && varname == &tmp_varname) {
32824 zval_dtor(&tmp_varname);
32825 }
32826 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
32827 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
32828 }
32829 PZVAL_LOCK(*retval);
32830 switch (type) {
32831 case BP_VAR_R:
32832 case BP_VAR_IS:
32833 EX_T(opline->result.var).var.ptr = *retval;
32834 break;
32835 case BP_VAR_UNSET: {
32836 zend_free_op free_res;
32837
32838 PZVAL_UNLOCK(*retval, &free_res);
32839 if (retval != &EG(uninitialized_zval_ptr)) {
32840 SEPARATE_ZVAL_IF_NOT_REF(retval);
32841 }
32842 PZVAL_LOCK(*retval);
32843 FREE_OP_VAR_PTR(free_res);
32844 }
32845 /* break missing intentionally */
32846 default:
32847 EX_T(opline->result.var).var.ptr_ptr = retval;
32848 break;
32849 }
32850 CHECK_EXCEPTION();
32851 ZEND_VM_NEXT_OPCODE();
32852 }
32853
ZEND_FETCH_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32854 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32855 {
32856 return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32857 }
32858
ZEND_FETCH_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32859 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32860 {
32861 return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32862 }
32863
ZEND_FETCH_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32864 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32865 {
32866 return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32867 }
32868
ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32869 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32870 {
32871 USE_OPLINE
32872
32873 return zend_fetch_var_address_helper_SPEC_CV_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32874 }
32875
ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32876 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32877 {
32878 return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32879 }
32880
ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32881 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32882 {
32883 return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32884 }
32885
ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32886 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32887 {
32888 USE_OPLINE
32889
32890 zval *container;
32891
32892 SAVE_OPLINE();
32893 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
32894 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
32895
32896 if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
32897
32898 }
32899 CHECK_EXCEPTION();
32900 ZEND_VM_NEXT_OPCODE();
32901 }
32902
ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32903 static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32904 {
32905 USE_OPLINE
32906 zend_free_op free_op1;
32907 zval **container;
32908
32909 SAVE_OPLINE();
32910 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
32911
32912 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32913 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
32914 }
32915 zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
32916
32917 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
32918 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
32919 }
32920
32921 /* We are going to assign the result by reference */
32922 if (UNEXPECTED(opline->extended_value != 0)) {
32923 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
32924
32925 if (retval_ptr) {
32926 Z_DELREF_PP(retval_ptr);
32927 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
32928 Z_ADDREF_PP(retval_ptr);
32929 }
32930 }
32931
32932 CHECK_EXCEPTION();
32933 ZEND_VM_NEXT_OPCODE();
32934 }
32935
ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32936 static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32937 {
32938 USE_OPLINE
32939 zend_free_op free_op1;
32940 zval **container;
32941
32942 SAVE_OPLINE();
32943 container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32944
32945 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32946 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
32947 }
32948 zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_RW TSRMLS_CC);
32949
32950 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
32951 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
32952 }
32953
32954 CHECK_EXCEPTION();
32955 ZEND_VM_NEXT_OPCODE();
32956 }
32957
ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32958 static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32959 {
32960 USE_OPLINE
32961
32962 zval *container;
32963
32964 SAVE_OPLINE();
32965 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
32966 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC);
32967
32968
32969 CHECK_EXCEPTION();
32970 ZEND_VM_NEXT_OPCODE();
32971 }
32972
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32973 static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32974 {
32975 USE_OPLINE
32976 zend_free_op free_op1;
32977
32978 SAVE_OPLINE();
32979
32980 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
32981 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
32982 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32983 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
32984 }
32985 zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
32986 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
32987 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
32988 }
32989
32990
32991 } else {
32992 zval *container;
32993
32994 if (IS_CONST == IS_UNUSED) {
32995 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
32996 }
32997 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
32998 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
32999
33000
33001 }
33002 CHECK_EXCEPTION();
33003 ZEND_VM_NEXT_OPCODE();
33004 }
33005
ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33006 static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33007 {
33008 USE_OPLINE
33009 zend_free_op free_op1;
33010 zval **container;
33011
33012 SAVE_OPLINE();
33013 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
33014
33015 if (IS_CV == IS_CV) {
33016 if (container != &EG(uninitialized_zval_ptr)) {
33017 SEPARATE_ZVAL_IF_NOT_REF(container);
33018 }
33019 }
33020 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
33021 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
33022 }
33023 zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_UNSET TSRMLS_CC);
33024
33025 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
33026 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
33027 }
33028
33029 if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
33030 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
33031 ZEND_VM_NEXT_OPCODE();
33032 } else {
33033 zend_free_op free_res;
33034 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
33035
33036 PZVAL_UNLOCK(*retval_ptr, &free_res);
33037 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
33038 SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
33039 }
33040 PZVAL_LOCK(*retval_ptr);
33041 FREE_OP_VAR_PTR(free_res);
33042 CHECK_EXCEPTION();
33043 ZEND_VM_NEXT_OPCODE();
33044 }
33045 }
33046
zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS)33047 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS)
33048 {
33049 USE_OPLINE
33050
33051 zval *container;
33052
33053 zval *offset;
33054
33055 SAVE_OPLINE();
33056 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
33057 offset = opline->op2.zv;
33058
33059 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
33060 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
33061 zend_error(E_NOTICE, "Trying to get property of non-object");
33062 PZVAL_LOCK(&EG(uninitialized_zval));
33063 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
33064
33065 } else {
33066 zval *retval;
33067
33068 if (0) {
33069 MAKE_REAL_ZVAL_PTR(offset);
33070 }
33071
33072 /* here we are sure we are dealing with an object */
33073 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
33074
33075 PZVAL_LOCK(retval);
33076 EX_T(opline->result.var).var.ptr = retval;
33077
33078 if (0) {
33079 zval_ptr_dtor(&offset);
33080 } else {
33081
33082 }
33083 }
33084
33085 CHECK_EXCEPTION();
33086 ZEND_VM_NEXT_OPCODE();
33087 }
33088
ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33089 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33090 {
33091 return zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
33092 }
33093
ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33094 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33095 {
33096 USE_OPLINE
33097 zend_free_op free_op1;
33098 zval *property;
33099 zval **container;
33100
33101 SAVE_OPLINE();
33102 property = opline->op2.zv;
33103
33104 if (0) {
33105 MAKE_REAL_ZVAL_PTR(property);
33106 }
33107 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33108 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
33109 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
33110 }
33111
33112 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
33113 if (0) {
33114 zval_ptr_dtor(&property);
33115 } else {
33116
33117 }
33118 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
33119 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
33120 }
33121
33122 /* We are going to assign the result by reference */
33123 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
33124 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
33125
33126 Z_DELREF_PP(retval_ptr);
33127 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
33128 Z_ADDREF_PP(retval_ptr);
33129 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
33130 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
33131 }
33132
33133 CHECK_EXCEPTION();
33134 ZEND_VM_NEXT_OPCODE();
33135 }
33136
ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33137 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33138 {
33139 USE_OPLINE
33140 zend_free_op free_op1;
33141 zval *property;
33142 zval **container;
33143
33144 SAVE_OPLINE();
33145 property = opline->op2.zv;
33146 container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
33147
33148 if (0) {
33149 MAKE_REAL_ZVAL_PTR(property);
33150 }
33151 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
33152 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
33153 }
33154 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
33155 if (0) {
33156 zval_ptr_dtor(&property);
33157 } else {
33158
33159 }
33160 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
33161 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
33162 }
33163
33164 CHECK_EXCEPTION();
33165 ZEND_VM_NEXT_OPCODE();
33166 }
33167
ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33168 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33169 {
33170 USE_OPLINE
33171
33172 zval *container;
33173
33174 zval *offset;
33175
33176 SAVE_OPLINE();
33177 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
33178 offset = opline->op2.zv;
33179
33180 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
33181 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
33182 PZVAL_LOCK(&EG(uninitialized_zval));
33183 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
33184
33185 } else {
33186 zval *retval;
33187
33188 if (0) {
33189 MAKE_REAL_ZVAL_PTR(offset);
33190 }
33191
33192 /* here we are sure we are dealing with an object */
33193 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
33194
33195 PZVAL_LOCK(retval);
33196 EX_T(opline->result.var).var.ptr = retval;
33197
33198 if (0) {
33199 zval_ptr_dtor(&offset);
33200 } else {
33201
33202 }
33203 }
33204
33205 CHECK_EXCEPTION();
33206 ZEND_VM_NEXT_OPCODE();
33207 }
33208
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33209 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33210 {
33211 USE_OPLINE
33212
33213 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
33214 /* Behave like FETCH_OBJ_W */
33215 zend_free_op free_op1;
33216 zval *property;
33217 zval **container;
33218
33219 SAVE_OPLINE();
33220 property = opline->op2.zv;
33221 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33222
33223 if (0) {
33224 MAKE_REAL_ZVAL_PTR(property);
33225 }
33226 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
33227 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
33228 }
33229 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
33230 if (0) {
33231 zval_ptr_dtor(&property);
33232 } else {
33233
33234 }
33235 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
33236 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
33237 }
33238
33239 CHECK_EXCEPTION();
33240 ZEND_VM_NEXT_OPCODE();
33241 } else {
33242 return zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
33243 }
33244 }
33245
ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33246 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33247 {
33248 USE_OPLINE
33249 zend_free_op free_op1, free_res;
33250 zval **container;
33251 zval *property;
33252
33253 SAVE_OPLINE();
33254 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
33255 property = opline->op2.zv;
33256
33257 if (IS_CV == IS_CV) {
33258 if (container != &EG(uninitialized_zval_ptr)) {
33259 SEPARATE_ZVAL_IF_NOT_REF(container);
33260 }
33261 }
33262 if (0) {
33263 MAKE_REAL_ZVAL_PTR(property);
33264 }
33265 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
33266 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
33267 }
33268 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
33269 if (0) {
33270 zval_ptr_dtor(&property);
33271 } else {
33272
33273 }
33274 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
33275 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
33276 }
33277
33278 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
33279 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
33280 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
33281 }
33282 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
33283 FREE_OP_VAR_PTR(free_res);
33284 CHECK_EXCEPTION();
33285 ZEND_VM_NEXT_OPCODE();
33286 }
33287
ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33288 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33289 {
33290 USE_OPLINE
33291
33292 zval **object_ptr;
33293 zval *property_name;
33294
33295 SAVE_OPLINE();
33296 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33297 property_name = opline->op2.zv;
33298
33299 if (0) {
33300 MAKE_REAL_ZVAL_PTR(property_name);
33301 }
33302 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
33303 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
33304 }
33305 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
33306 if (0) {
33307 zval_ptr_dtor(&property_name);
33308 } else {
33309
33310 }
33311
33312 /* assign_obj has two opcodes! */
33313 CHECK_EXCEPTION();
33314 ZEND_VM_INC_OPCODE();
33315 ZEND_VM_NEXT_OPCODE();
33316 }
33317
ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33318 static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33319 {
33320 USE_OPLINE
33321
33322 zval **object_ptr;
33323
33324 SAVE_OPLINE();
33325 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33326
33327 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
33328 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
33329 }
33330 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
33331
33332 zval *property_name = opline->op2.zv;
33333
33334 if (0) {
33335 MAKE_REAL_ZVAL_PTR(property_name);
33336 }
33337 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
33338 if (0) {
33339 zval_ptr_dtor(&property_name);
33340 } else {
33341
33342 }
33343 } else {
33344 zend_free_op free_op_data1, free_op_data2;
33345 zval *value;
33346 zval *dim = opline->op2.zv;
33347 zval **variable_ptr_ptr;
33348
33349 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC);
33350
33351 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
33352 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
33353 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
33354 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
33355 if (RETURN_VALUE_USED(opline)) {
33356 zval *retval;
33357
33358 ALLOC_ZVAL(retval);
33359 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
33360 INIT_PZVAL(retval);
33361 EX_T(opline->result.var).var.ptr = retval;
33362 }
33363 } else if (RETURN_VALUE_USED(opline)) {
33364 PZVAL_LOCK(&EG(uninitialized_zval));
33365 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
33366 }
33367 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
33368 if (IS_TMP_FREE(free_op_data1)) {
33369 zval_dtor(value);
33370 }
33371 if (RETURN_VALUE_USED(opline)) {
33372 PZVAL_LOCK(&EG(uninitialized_zval));
33373 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
33374 }
33375 } else {
33376 if ((opline+1)->op1_type == IS_TMP_VAR) {
33377 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33378 } else if ((opline+1)->op1_type == IS_CONST) {
33379 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33380 } else {
33381 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33382 }
33383 if (RETURN_VALUE_USED(opline)) {
33384 PZVAL_LOCK(value);
33385 EX_T(opline->result.var).var.ptr = value;
33386 }
33387 }
33388 FREE_OP_VAR_PTR(free_op_data2);
33389 FREE_OP_IF_VAR(free_op_data1);
33390 }
33391
33392 /* assign_dim has two opcodes! */
33393 CHECK_EXCEPTION();
33394 ZEND_VM_INC_OPCODE();
33395 ZEND_VM_NEXT_OPCODE();
33396 }
33397
ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33398 static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33399 {
33400 USE_OPLINE
33401
33402 zval *value;
33403 zval **variable_ptr_ptr;
33404
33405 SAVE_OPLINE();
33406 value = opline->op2.zv;
33407 variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33408
33409 if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
33410 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) {
33411 if (RETURN_VALUE_USED(opline)) {
33412 zval *retval;
33413
33414 ALLOC_ZVAL(retval);
33415 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
33416 INIT_PZVAL(retval);
33417 EX_T(opline->result.var).var.ptr = retval;
33418 }
33419 } else if (RETURN_VALUE_USED(opline)) {
33420 PZVAL_LOCK(&EG(uninitialized_zval));
33421 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
33422 }
33423 } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
33424 if (0) {
33425 zval_dtor(value);
33426 }
33427 if (RETURN_VALUE_USED(opline)) {
33428 PZVAL_LOCK(&EG(uninitialized_zval));
33429 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
33430 }
33431 } else {
33432 if (IS_CONST == IS_TMP_VAR) {
33433 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33434 } else if (IS_CONST == IS_CONST) {
33435 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33436 } else {
33437 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33438 }
33439 if (RETURN_VALUE_USED(opline)) {
33440 PZVAL_LOCK(value);
33441 EX_T(opline->result.var).var.ptr = value;
33442 }
33443 }
33444
33445 if (IS_CV == IS_VAR && 0) {
33446 zval_ptr_dtor_nogc(&value);
33447 }
33448
33449 /* zend_assign_to_variable() always takes care of op2, never free it! */
33450
33451 CHECK_EXCEPTION();
33452 ZEND_VM_NEXT_OPCODE();
33453 }
33454
ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33455 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33456 {
33457 USE_OPLINE
33458 zval *function_name;
33459 char *function_name_strval;
33460 int function_name_strlen;
33461
33462 call_slot *call = EX(call_slots) + opline->result.num;
33463
33464 SAVE_OPLINE();
33465
33466 function_name = opline->op2.zv;
33467
33468 if (IS_CONST != IS_CONST &&
33469 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
33470 if (UNEXPECTED(EG(exception) != NULL)) {
33471 HANDLE_EXCEPTION();
33472 }
33473 zend_error_noreturn(E_ERROR, "Method name must be a string");
33474 }
33475
33476 function_name_strval = Z_STRVAL_P(function_name);
33477 function_name_strlen = Z_STRLEN_P(function_name);
33478
33479 call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
33480
33481 if (EXPECTED(call->object != NULL) &&
33482 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
33483 call->called_scope = Z_OBJCE_P(call->object);
33484
33485 if (IS_CONST != IS_CONST ||
33486 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
33487 zval *object = call->object;
33488
33489 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
33490 zend_error_noreturn(E_ERROR, "Object does not support method calls");
33491 }
33492
33493 /* First, locate the function. */
33494 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
33495 if (UNEXPECTED(call->fbc == NULL)) {
33496 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
33497 }
33498 if (IS_CONST == IS_CONST &&
33499 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
33500 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
33501 EXPECTED(call->object == object)) {
33502 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
33503 }
33504 }
33505 } else {
33506 if (UNEXPECTED(EG(exception) != NULL)) {
33507
33508 HANDLE_EXCEPTION();
33509 }
33510 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
33511 }
33512
33513 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
33514 call->object = NULL;
33515 } else {
33516 if (!PZVAL_IS_REF(call->object)) {
33517 Z_ADDREF_P(call->object); /* For $this pointer */
33518 } else {
33519 zval *this_ptr;
33520 ALLOC_ZVAL(this_ptr);
33521 INIT_PZVAL_COPY(this_ptr, call->object);
33522 zval_copy_ctor(this_ptr);
33523 call->object = this_ptr;
33524 }
33525 }
33526
33527 call->num_additional_args = 0;
33528 call->is_ctor_call = 0;
33529 EX(call) = call;
33530
33531
33532 CHECK_EXCEPTION();
33533 ZEND_VM_NEXT_OPCODE();
33534 }
33535
ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33536 static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33537 {
33538 USE_OPLINE
33539
33540
33541 SAVE_OPLINE();
33542 is_equal_function(&EX_T(opline->result.var).tmp_var,
33543 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
33544 opline->op2.zv TSRMLS_CC);
33545
33546 CHECK_EXCEPTION();
33547 ZEND_VM_NEXT_OPCODE();
33548 }
33549
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33550 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33551 {
33552 USE_OPLINE
33553
33554 zval *expr_ptr;
33555
33556 SAVE_OPLINE();
33557 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
33558 zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33559
33560 if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
33561 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
33562 }
33563 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
33564 expr_ptr = *expr_ptr_ptr;
33565 Z_ADDREF_P(expr_ptr);
33566 } else {
33567 expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
33568 if (0) { /* temporary variable */
33569 zval *new_expr;
33570
33571 ALLOC_ZVAL(new_expr);
33572 INIT_PZVAL_COPY(new_expr, expr_ptr);
33573 expr_ptr = new_expr;
33574 } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
33575 zval *new_expr;
33576
33577 ALLOC_ZVAL(new_expr);
33578 INIT_PZVAL_COPY(new_expr, expr_ptr);
33579 expr_ptr = new_expr;
33580 zendi_zval_copy_ctor(*expr_ptr);
33581
33582 } else if (IS_CV == IS_CV) {
33583 Z_ADDREF_P(expr_ptr);
33584 }
33585 }
33586
33587 if (IS_CONST != IS_UNUSED) {
33588
33589 zval *offset = opline->op2.zv;
33590 ulong hval;
33591
33592 switch (Z_TYPE_P(offset)) {
33593 case IS_DOUBLE:
33594 hval = zend_dval_to_lval(Z_DVAL_P(offset));
33595 goto num_index;
33596 case IS_LONG:
33597 case IS_BOOL:
33598 hval = Z_LVAL_P(offset);
33599 num_index:
33600 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
33601 break;
33602 case IS_STRING:
33603 if (IS_CONST == IS_CONST) {
33604 hval = Z_HASH_P(offset);
33605 } else {
33606 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
33607 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
33608 }
33609 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
33610 break;
33611 case IS_NULL:
33612 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
33613 break;
33614 default:
33615 zend_error(E_WARNING, "Illegal offset type");
33616 zval_ptr_dtor(&expr_ptr);
33617 /* do nothing */
33618 break;
33619 }
33620
33621 } else {
33622 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
33623 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
33624 zval_ptr_dtor(&expr_ptr);
33625 }
33626 }
33627 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
33628
33629 }
33630 CHECK_EXCEPTION();
33631 ZEND_VM_NEXT_OPCODE();
33632 }
33633
ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33634 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33635 {
33636 USE_OPLINE
33637
33638 array_init(&EX_T(opline->result.var).tmp_var);
33639 if (IS_CV == IS_UNUSED) {
33640 ZEND_VM_NEXT_OPCODE();
33641 #if 0 || IS_CV != IS_UNUSED
33642 } else {
33643 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
33644 #endif
33645 }
33646 }
33647
ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33648 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33649 {
33650 USE_OPLINE
33651 zval tmp, *varname;
33652 HashTable *target_symbol_table;
33653
33654
33655 SAVE_OPLINE();
33656 if (IS_CV == IS_CV &&
33657 IS_CONST == IS_UNUSED &&
33658 (opline->extended_value & ZEND_QUICK_SET)) {
33659 if (EG(active_symbol_table)) {
33660 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
33661
33662 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
33663 EX_CV(opline->op1.var) = NULL;
33664 } else if (EX_CV(opline->op1.var)) {
33665 zval_ptr_dtor(EX_CV(opline->op1.var));
33666 EX_CV(opline->op1.var) = NULL;
33667 }
33668 CHECK_EXCEPTION();
33669 ZEND_VM_NEXT_OPCODE();
33670 }
33671
33672 varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
33673
33674 if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
33675 ZVAL_COPY_VALUE(&tmp, varname);
33676 zval_copy_ctor(&tmp);
33677 convert_to_string(&tmp);
33678 varname = &tmp;
33679 } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
33680 Z_ADDREF_P(varname);
33681 }
33682
33683 if (IS_CONST != IS_UNUSED) {
33684 zend_class_entry *ce;
33685
33686 if (IS_CONST == IS_CONST) {
33687 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
33688 ce = CACHED_PTR(opline->op2.literal->cache_slot);
33689 } else {
33690 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
33691 if (UNEXPECTED(EG(exception) != NULL)) {
33692 if (IS_CV != IS_CONST && varname == &tmp) {
33693 zval_dtor(&tmp);
33694 } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
33695 zval_ptr_dtor(&varname);
33696 }
33697
33698 HANDLE_EXCEPTION();
33699 }
33700 if (UNEXPECTED(ce == NULL)) {
33701 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
33702 }
33703 CACHE_PTR(opline->op2.literal->cache_slot, ce);
33704 }
33705 } else {
33706 ce = EX_T(opline->op2.var).class_entry;
33707 }
33708 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
33709 } else {
33710 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
33711
33712 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
33713 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
33714 }
33715
33716 if (IS_CV != IS_CONST && varname == &tmp) {
33717 zval_dtor(&tmp);
33718 } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
33719 zval_ptr_dtor(&varname);
33720 }
33721
33722 CHECK_EXCEPTION();
33723 ZEND_VM_NEXT_OPCODE();
33724 }
33725
ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33726 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33727 {
33728 USE_OPLINE
33729
33730 zval **container;
33731 zval *offset;
33732 ulong hval;
33733
33734 SAVE_OPLINE();
33735 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
33736 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
33737 SEPARATE_ZVAL_IF_NOT_REF(container);
33738 }
33739 offset = opline->op2.zv;
33740
33741 if (IS_CV != IS_VAR || container) {
33742 switch (Z_TYPE_PP(container)) {
33743 case IS_ARRAY: {
33744 HashTable *ht = Z_ARRVAL_PP(container);
33745
33746 switch (Z_TYPE_P(offset)) {
33747 case IS_DOUBLE:
33748 hval = zend_dval_to_lval(Z_DVAL_P(offset));
33749 zend_hash_index_del(ht, hval);
33750 break;
33751 case IS_RESOURCE:
33752 case IS_BOOL:
33753 case IS_LONG:
33754 hval = Z_LVAL_P(offset);
33755 zend_hash_index_del(ht, hval);
33756 break;
33757 case IS_STRING:
33758 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
33759 Z_ADDREF_P(offset);
33760 }
33761 if (IS_CONST == IS_CONST) {
33762 hval = Z_HASH_P(offset);
33763 } else {
33764 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
33765 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
33766 }
33767 if (ht == &EG(symbol_table)) {
33768 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
33769 } else {
33770 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
33771 }
33772 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
33773 zval_ptr_dtor(&offset);
33774 }
33775 break;
33776 num_index_dim:
33777 zend_hash_index_del(ht, hval);
33778 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
33779 zval_ptr_dtor(&offset);
33780 }
33781 break;
33782 case IS_NULL:
33783 zend_hash_del(ht, "", sizeof(""));
33784 break;
33785 default:
33786 zend_error(E_WARNING, "Illegal offset type in unset");
33787 break;
33788 }
33789
33790 break;
33791 }
33792 case IS_OBJECT:
33793 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
33794 zend_error_noreturn(E_ERROR, "Cannot use object as array");
33795 }
33796 if (0) {
33797 MAKE_REAL_ZVAL_PTR(offset);
33798 }
33799 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
33800 if (0) {
33801 zval_ptr_dtor(&offset);
33802 } else {
33803
33804 }
33805 break;
33806 case IS_STRING:
33807 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
33808 ZEND_VM_CONTINUE(); /* bailed out before */
33809 default:
33810
33811 break;
33812 }
33813 } else {
33814
33815 }
33816
33817 CHECK_EXCEPTION();
33818 ZEND_VM_NEXT_OPCODE();
33819 }
33820
ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33821 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33822 {
33823 USE_OPLINE
33824
33825 zval **container;
33826 zval *offset;
33827
33828 SAVE_OPLINE();
33829 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
33830 offset = opline->op2.zv;
33831
33832 if (IS_CV != IS_VAR || container) {
33833 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
33834 SEPARATE_ZVAL_IF_NOT_REF(container);
33835 }
33836 if (Z_TYPE_PP(container) == IS_OBJECT) {
33837 if (0) {
33838 MAKE_REAL_ZVAL_PTR(offset);
33839 }
33840 if (Z_OBJ_HT_P(*container)->unset_property) {
33841 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
33842 } else {
33843 zend_error(E_NOTICE, "Trying to unset property of non-object");
33844 }
33845 if (0) {
33846 zval_ptr_dtor(&offset);
33847 } else {
33848
33849 }
33850 } else {
33851
33852 }
33853 } else {
33854
33855 }
33856
33857 CHECK_EXCEPTION();
33858 ZEND_VM_NEXT_OPCODE();
33859 }
33860
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33861 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33862 {
33863 USE_OPLINE
33864 zval **value;
33865 zend_bool isset = 1;
33866
33867 SAVE_OPLINE();
33868 if (IS_CV == IS_CV &&
33869 IS_CONST == IS_UNUSED &&
33870 (opline->extended_value & ZEND_QUICK_SET)) {
33871 if (EX_CV(opline->op1.var)) {
33872 value = EX_CV(opline->op1.var);
33873 } else if (EG(active_symbol_table)) {
33874 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
33875
33876 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
33877 isset = 0;
33878 }
33879 } else {
33880 isset = 0;
33881 }
33882 } else {
33883 HashTable *target_symbol_table;
33884
33885 zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
33886
33887 if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
33888 ZVAL_COPY_VALUE(&tmp, varname);
33889 zval_copy_ctor(&tmp);
33890 convert_to_string(&tmp);
33891 varname = &tmp;
33892 }
33893
33894 if (IS_CONST != IS_UNUSED) {
33895 zend_class_entry *ce;
33896
33897 if (IS_CONST == IS_CONST) {
33898 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
33899 ce = CACHED_PTR(opline->op2.literal->cache_slot);
33900 } else {
33901 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
33902 if (UNEXPECTED(ce == NULL)) {
33903 CHECK_EXCEPTION();
33904 ZEND_VM_NEXT_OPCODE();
33905 }
33906 CACHE_PTR(opline->op2.literal->cache_slot, ce);
33907 }
33908 } else {
33909 ce = EX_T(opline->op2.var).class_entry;
33910 }
33911 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
33912 if (!value) {
33913 isset = 0;
33914 }
33915 } else {
33916 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
33917 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
33918 isset = 0;
33919 }
33920 }
33921
33922 if (IS_CV != IS_CONST && varname == &tmp) {
33923 zval_dtor(&tmp);
33924 }
33925
33926 }
33927
33928 if (opline->extended_value & ZEND_ISSET) {
33929 if (isset && Z_TYPE_PP(value) != IS_NULL) {
33930 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
33931 } else {
33932 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
33933 }
33934 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
33935 if (!isset || !i_zend_is_true(*value)) {
33936 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
33937 } else {
33938 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
33939 }
33940 }
33941
33942 CHECK_EXCEPTION();
33943 ZEND_VM_NEXT_OPCODE();
33944 }
33945
zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)33946 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
33947 {
33948 USE_OPLINE
33949
33950 zval *container;
33951 zval **value = NULL;
33952 int result = 0;
33953 ulong hval;
33954 zval *offset;
33955
33956 SAVE_OPLINE();
33957 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
33958 offset = opline->op2.zv;
33959
33960 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
33961 HashTable *ht;
33962 int isset = 0;
33963
33964 ht = Z_ARRVAL_P(container);
33965
33966 switch (Z_TYPE_P(offset)) {
33967 case IS_DOUBLE:
33968 hval = zend_dval_to_lval(Z_DVAL_P(offset));
33969 goto num_index_prop;
33970 case IS_RESOURCE:
33971 case IS_BOOL:
33972 case IS_LONG:
33973 hval = Z_LVAL_P(offset);
33974 num_index_prop:
33975 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
33976 isset = 1;
33977 }
33978 break;
33979 case IS_STRING:
33980 if (IS_CONST == IS_CONST) {
33981 hval = Z_HASH_P(offset);
33982 } else {
33983 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
33984 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
33985 }
33986 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
33987 isset = 1;
33988 }
33989 break;
33990 case IS_NULL:
33991 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
33992 isset = 1;
33993 }
33994 break;
33995 default:
33996 zend_error(E_WARNING, "Illegal offset type in isset or empty");
33997 break;
33998 }
33999
34000 if (opline->extended_value & ZEND_ISSET) {
34001 if (isset && Z_TYPE_PP(value) == IS_NULL) {
34002 result = 0;
34003 } else {
34004 result = isset;
34005 }
34006 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
34007 if (!isset || !i_zend_is_true(*value)) {
34008 result = 0;
34009 } else {
34010 result = 1;
34011 }
34012 }
34013
34014 } else if (Z_TYPE_P(container) == IS_OBJECT) {
34015 if (0) {
34016 MAKE_REAL_ZVAL_PTR(offset);
34017 }
34018 if (prop_dim) {
34019 if (Z_OBJ_HT_P(container)->has_property) {
34020 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34021 } else {
34022 zend_error(E_NOTICE, "Trying to check property of non-object");
34023 result = 0;
34024 }
34025 } else {
34026 if (Z_OBJ_HT_P(container)->has_dimension) {
34027 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
34028 } else {
34029 zend_error(E_NOTICE, "Trying to check element of non-array");
34030 result = 0;
34031 }
34032 }
34033 if (0) {
34034 zval_ptr_dtor(&offset);
34035 } else {
34036
34037 }
34038 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
34039 zval tmp;
34040
34041 if (Z_TYPE_P(offset) != IS_LONG) {
34042 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
34043 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
34044 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
34045 ZVAL_COPY_VALUE(&tmp, offset);
34046 zval_copy_ctor(&tmp);
34047 convert_to_long(&tmp);
34048 offset = &tmp;
34049 } else {
34050 /* can not be converted to proper offset, return "not set" */
34051 result = 0;
34052 }
34053 }
34054 if (Z_TYPE_P(offset) == IS_LONG) {
34055 if (opline->extended_value & ZEND_ISSET) {
34056 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
34057 result = 1;
34058 }
34059 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
34060 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
34061 result = 1;
34062 }
34063 }
34064 }
34065
34066 } else {
34067
34068 }
34069
34070 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
34071 if (opline->extended_value & ZEND_ISSET) {
34072 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
34073 } else {
34074 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
34075 }
34076
34077 CHECK_EXCEPTION();
34078 ZEND_VM_NEXT_OPCODE();
34079 }
34080
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34081 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34082 {
34083 return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34084 }
34085
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34086 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34087 {
34088 return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34089 }
34090
ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34091 static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34092 {
34093 USE_OPLINE
34094
34095 /* The generator object is stored in return_value_ptr_ptr */
34096 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
34097
34098 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
34099 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
34100 }
34101
34102 /* Destroy the previously yielded value */
34103 if (generator->value) {
34104 zval_ptr_dtor(&generator->value);
34105 }
34106
34107 /* Destroy the previously yielded key */
34108 if (generator->key) {
34109 zval_ptr_dtor(&generator->key);
34110 }
34111
34112 /* Set the new yielded value */
34113 if (IS_CV != IS_UNUSED) {
34114
34115
34116 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
34117 /* Constants and temporary variables aren't yieldable by reference,
34118 * but we still allow them with a notice. */
34119 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
34120 zval *value, *copy;
34121
34122 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
34123
34124 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
34125 ALLOC_ZVAL(copy);
34126 INIT_PZVAL_COPY(copy, value);
34127
34128 /* Temporary variables don't need ctor copying */
34129 if (!0) {
34130 zval_copy_ctor(copy);
34131 }
34132
34133 generator->value = copy;
34134 } else {
34135 zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
34136
34137 if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
34138 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
34139 }
34140
34141 /* If a function call result is yielded and the function did
34142 * not return by reference we throw a notice. */
34143 if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
34144 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
34145 && EX_T(opline->op1.var).var.fcall_returned_reference)
34146 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
34147 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
34148
34149 Z_ADDREF_PP(value_ptr);
34150 generator->value = *value_ptr;
34151 } else {
34152 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
34153 Z_ADDREF_PP(value_ptr);
34154 generator->value = *value_ptr;
34155 }
34156
34157 }
34158 } else {
34159 zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
34160
34161 /* Consts, temporary variables and references need copying */
34162 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
34163 || PZVAL_IS_REF(value)
34164 ) {
34165 zval *copy;
34166
34167 ALLOC_ZVAL(copy);
34168 INIT_PZVAL_COPY(copy, value);
34169
34170 /* Temporary variables don't need ctor copying */
34171 if (!0) {
34172 zval_copy_ctor(copy);
34173 }
34174
34175 generator->value = copy;
34176
34177 } else {
34178 if (IS_CV == IS_CV) {
34179 Z_ADDREF_P(value);
34180 }
34181 generator->value = value;
34182 }
34183 }
34184 } else {
34185 /* If no value was specified yield null */
34186 Z_ADDREF(EG(uninitialized_zval));
34187 generator->value = &EG(uninitialized_zval);
34188 }
34189
34190 /* Set the new yielded key */
34191 if (IS_CONST != IS_UNUSED) {
34192
34193 zval *key = opline->op2.zv;
34194
34195 /* Consts, temporary variables and references need copying */
34196 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
34197 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
34198 ) {
34199 zval *copy;
34200
34201 ALLOC_ZVAL(copy);
34202 INIT_PZVAL_COPY(copy, key);
34203
34204 /* Temporary variables don't need ctor copying */
34205 if (!0) {
34206 zval_copy_ctor(copy);
34207 }
34208
34209 generator->key = copy;
34210 } else {
34211 Z_ADDREF_P(key);
34212 generator->key = key;
34213 }
34214
34215 if (Z_TYPE_P(generator->key) == IS_LONG
34216 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
34217 ) {
34218 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
34219 }
34220
34221 } else {
34222 /* If no key was specified we use auto-increment keys */
34223 generator->largest_used_integer_key++;
34224
34225 ALLOC_INIT_ZVAL(generator->key);
34226 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
34227 }
34228
34229 if (RETURN_VALUE_USED(opline)) {
34230 /* If the return value of yield is used set the send
34231 * target and initialize it to NULL */
34232 generator->send_target = &EX_T(opline->result.var).var.ptr;
34233 Z_ADDREF(EG(uninitialized_zval));
34234 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
34235 } else {
34236 generator->send_target = NULL;
34237 }
34238
34239 /* We increment to the next op, so we are at the correct position when the
34240 * generator is resumed. */
34241 ZEND_VM_INC_OPCODE();
34242
34243 /* The GOTO VM uses a local opline variable. We need to set the opline
34244 * variable in execute_data so we don't resume at an old position. */
34245 SAVE_OPLINE();
34246
34247 ZEND_VM_RETURN();
34248 }
34249
ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34250 static int ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34251 {
34252 USE_OPLINE
34253
34254
34255 SAVE_OPLINE();
34256 pow_function(&EX_T(opline->result.var).tmp_var,
34257 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34258 opline->op2.zv TSRMLS_CC);
34259
34260
34261 CHECK_EXCEPTION();
34262 ZEND_VM_NEXT_OPCODE();
34263 }
34264
ZEND_ASSIGN_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34265 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34266 {
34267 return zend_binary_assign_op_helper_SPEC_CV_CONST(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34268 }
34269
ZEND_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34270 static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34271 {
34272 USE_OPLINE
34273 zend_free_op free_op2;
34274
34275 SAVE_OPLINE();
34276 fast_add_function(&EX_T(opline->result.var).tmp_var,
34277 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34278 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34279
34280 zval_dtor(free_op2.var);
34281 CHECK_EXCEPTION();
34282 ZEND_VM_NEXT_OPCODE();
34283 }
34284
ZEND_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34285 static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34286 {
34287 USE_OPLINE
34288 zend_free_op free_op2;
34289
34290 SAVE_OPLINE();
34291 fast_sub_function(&EX_T(opline->result.var).tmp_var,
34292 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34293 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34294
34295 zval_dtor(free_op2.var);
34296 CHECK_EXCEPTION();
34297 ZEND_VM_NEXT_OPCODE();
34298 }
34299
ZEND_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34300 static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34301 {
34302 USE_OPLINE
34303 zend_free_op free_op2;
34304
34305 SAVE_OPLINE();
34306 fast_mul_function(&EX_T(opline->result.var).tmp_var,
34307 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34308 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34309
34310 zval_dtor(free_op2.var);
34311 CHECK_EXCEPTION();
34312 ZEND_VM_NEXT_OPCODE();
34313 }
34314
ZEND_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34315 static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34316 {
34317 USE_OPLINE
34318 zend_free_op free_op2;
34319
34320 SAVE_OPLINE();
34321 fast_div_function(&EX_T(opline->result.var).tmp_var,
34322 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34323 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34324
34325 zval_dtor(free_op2.var);
34326 CHECK_EXCEPTION();
34327 ZEND_VM_NEXT_OPCODE();
34328 }
34329
ZEND_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34330 static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34331 {
34332 USE_OPLINE
34333 zend_free_op free_op2;
34334
34335 SAVE_OPLINE();
34336 fast_mod_function(&EX_T(opline->result.var).tmp_var,
34337 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34338 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34339
34340 zval_dtor(free_op2.var);
34341 CHECK_EXCEPTION();
34342 ZEND_VM_NEXT_OPCODE();
34343 }
34344
ZEND_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34345 static int ZEND_FASTCALL ZEND_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34346 {
34347 USE_OPLINE
34348 zend_free_op free_op2;
34349
34350 SAVE_OPLINE();
34351 shift_left_function(&EX_T(opline->result.var).tmp_var,
34352 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34353 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34354
34355 zval_dtor(free_op2.var);
34356 CHECK_EXCEPTION();
34357 ZEND_VM_NEXT_OPCODE();
34358 }
34359
ZEND_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34360 static int ZEND_FASTCALL ZEND_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34361 {
34362 USE_OPLINE
34363 zend_free_op free_op2;
34364
34365 SAVE_OPLINE();
34366 shift_right_function(&EX_T(opline->result.var).tmp_var,
34367 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34368 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34369
34370 zval_dtor(free_op2.var);
34371 CHECK_EXCEPTION();
34372 ZEND_VM_NEXT_OPCODE();
34373 }
34374
ZEND_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34375 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34376 {
34377 USE_OPLINE
34378 zend_free_op free_op2;
34379
34380 SAVE_OPLINE();
34381 concat_function(&EX_T(opline->result.var).tmp_var,
34382 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34383 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34384
34385 zval_dtor(free_op2.var);
34386 CHECK_EXCEPTION();
34387 ZEND_VM_NEXT_OPCODE();
34388 }
34389
ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34390 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34391 {
34392 USE_OPLINE
34393 zend_free_op free_op2;
34394
34395 SAVE_OPLINE();
34396 is_identical_function(&EX_T(opline->result.var).tmp_var,
34397 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34398 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34399
34400 zval_dtor(free_op2.var);
34401 CHECK_EXCEPTION();
34402 ZEND_VM_NEXT_OPCODE();
34403 }
34404
ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34405 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34406 {
34407 USE_OPLINE
34408 zend_free_op free_op2;
34409 zval *result = &EX_T(opline->result.var).tmp_var;
34410
34411 SAVE_OPLINE();
34412 is_identical_function(result,
34413 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34414 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34415 Z_LVAL_P(result) = !Z_LVAL_P(result);
34416
34417 zval_dtor(free_op2.var);
34418 CHECK_EXCEPTION();
34419 ZEND_VM_NEXT_OPCODE();
34420 }
34421
ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34422 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34423 {
34424 USE_OPLINE
34425 zend_free_op free_op2;
34426 zval *result = &EX_T(opline->result.var).tmp_var;
34427
34428 SAVE_OPLINE();
34429 ZVAL_BOOL(result, fast_equal_function(result,
34430 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34431 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
34432
34433 zval_dtor(free_op2.var);
34434 CHECK_EXCEPTION();
34435 ZEND_VM_NEXT_OPCODE();
34436 }
34437
ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34438 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34439 {
34440 USE_OPLINE
34441 zend_free_op free_op2;
34442 zval *result = &EX_T(opline->result.var).tmp_var;
34443
34444 SAVE_OPLINE();
34445 ZVAL_BOOL(result, fast_not_equal_function(result,
34446 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34447 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
34448
34449 zval_dtor(free_op2.var);
34450 CHECK_EXCEPTION();
34451 ZEND_VM_NEXT_OPCODE();
34452 }
34453
ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34454 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34455 {
34456 USE_OPLINE
34457 zend_free_op free_op2;
34458 zval *result = &EX_T(opline->result.var).tmp_var;
34459
34460 SAVE_OPLINE();
34461 ZVAL_BOOL(result, fast_is_smaller_function(result,
34462 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34463 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
34464
34465 zval_dtor(free_op2.var);
34466 CHECK_EXCEPTION();
34467 ZEND_VM_NEXT_OPCODE();
34468 }
34469
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34470 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34471 {
34472 USE_OPLINE
34473 zend_free_op free_op2;
34474 zval *result = &EX_T(opline->result.var).tmp_var;
34475
34476 SAVE_OPLINE();
34477 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
34478 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34479 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
34480
34481 zval_dtor(free_op2.var);
34482 CHECK_EXCEPTION();
34483 ZEND_VM_NEXT_OPCODE();
34484 }
34485
ZEND_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34486 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34487 {
34488 USE_OPLINE
34489 zend_free_op free_op2;
34490
34491 SAVE_OPLINE();
34492 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
34493 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34494 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34495
34496 zval_dtor(free_op2.var);
34497 CHECK_EXCEPTION();
34498 ZEND_VM_NEXT_OPCODE();
34499 }
34500
ZEND_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34501 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34502 {
34503 USE_OPLINE
34504 zend_free_op free_op2;
34505
34506 SAVE_OPLINE();
34507 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
34508 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34509 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34510
34511 zval_dtor(free_op2.var);
34512 CHECK_EXCEPTION();
34513 ZEND_VM_NEXT_OPCODE();
34514 }
34515
ZEND_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34516 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34517 {
34518 USE_OPLINE
34519 zend_free_op free_op2;
34520
34521 SAVE_OPLINE();
34522 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
34523 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34524 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34525
34526 zval_dtor(free_op2.var);
34527 CHECK_EXCEPTION();
34528 ZEND_VM_NEXT_OPCODE();
34529 }
34530
ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34531 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34532 {
34533 USE_OPLINE
34534 zend_free_op free_op2;
34535
34536 SAVE_OPLINE();
34537 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
34538 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34539 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34540
34541 zval_dtor(free_op2.var);
34542 CHECK_EXCEPTION();
34543 ZEND_VM_NEXT_OPCODE();
34544 }
34545
zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)34546 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
34547 {
34548 USE_OPLINE
34549 zend_free_op free_op2, free_op_data1;
34550 zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34551 zval *object;
34552 zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34553 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
34554 int have_get_ptr = 0;
34555
34556 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
34557 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
34558 }
34559
34560 make_real_object(object_ptr TSRMLS_CC);
34561 object = *object_ptr;
34562
34563 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34564 zend_error(E_WARNING, "Attempt to assign property of non-object");
34565 zval_dtor(free_op2.var);
34566 FREE_OP(free_op_data1);
34567
34568 if (RETURN_VALUE_USED(opline)) {
34569 PZVAL_LOCK(&EG(uninitialized_zval));
34570 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
34571 }
34572 } else {
34573 /* here we are sure we are dealing with an object */
34574 if (1) {
34575 MAKE_REAL_ZVAL_PTR(property);
34576 }
34577
34578 /* here property is a string */
34579 if (opline->extended_value == ZEND_ASSIGN_OBJ
34580 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
34581 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34582 if (zptr != NULL) { /* NULL means no success in getting PTR */
34583 have_get_ptr = 1;
34584 if (UNEXPECTED(*zptr == &EG(error_zval))) {
34585 if (RETURN_VALUE_USED(opline)) {
34586 PZVAL_LOCK(&EG(uninitialized_zval));
34587 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
34588 }
34589 } else {
34590 SEPARATE_ZVAL_IF_NOT_REF(zptr);
34591
34592 binary_op(*zptr, *zptr, value TSRMLS_CC);
34593 if (RETURN_VALUE_USED(opline)) {
34594 PZVAL_LOCK(*zptr);
34595 EX_T(opline->result.var).var.ptr = *zptr;
34596 }
34597 }
34598 }
34599 }
34600
34601 if (!have_get_ptr) {
34602 zval *z = NULL;
34603
34604 Z_ADDREF_P(object);
34605 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
34606 if (Z_OBJ_HT_P(object)->read_property) {
34607 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34608 }
34609 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
34610 if (Z_OBJ_HT_P(object)->read_dimension) {
34611 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
34612 }
34613 }
34614 if (z) {
34615 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
34616 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
34617
34618 if (Z_REFCOUNT_P(z) == 0) {
34619 GC_REMOVE_ZVAL_FROM_BUFFER(z);
34620 zval_dtor(z);
34621 FREE_ZVAL(z);
34622 }
34623 z = value;
34624 }
34625 Z_ADDREF_P(z);
34626 SEPARATE_ZVAL_IF_NOT_REF(&z);
34627 binary_op(z, z, value TSRMLS_CC);
34628 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
34629 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34630 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
34631 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
34632 }
34633 if (RETURN_VALUE_USED(opline)) {
34634 PZVAL_LOCK(z);
34635 EX_T(opline->result.var).var.ptr = z;
34636 }
34637 zval_ptr_dtor(&z);
34638 } else {
34639 zend_error(E_WARNING, "Attempt to assign property of non-object");
34640 if (RETURN_VALUE_USED(opline)) {
34641 PZVAL_LOCK(&EG(uninitialized_zval));
34642 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
34643 }
34644 }
34645 zval_ptr_dtor(&object);
34646 }
34647
34648 if (1) {
34649 zval_ptr_dtor(&property);
34650 } else {
34651 zval_dtor(free_op2.var);
34652 }
34653 FREE_OP(free_op_data1);
34654 }
34655
34656 /* assign_obj has two opcodes! */
34657 CHECK_EXCEPTION();
34658 ZEND_VM_INC_OPCODE();
34659 ZEND_VM_NEXT_OPCODE();
34660 }
34661
zend_binary_assign_op_helper_SPEC_CV_TMP(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)34662 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
34663 {
34664 USE_OPLINE
34665 zend_free_op free_op2, free_op_data2, free_op_data1;
34666 zval **var_ptr;
34667 zval *value;
34668
34669 SAVE_OPLINE();
34670 switch (opline->extended_value) {
34671 case ZEND_ASSIGN_OBJ:
34672 return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34673 break;
34674 case ZEND_ASSIGN_DIM: {
34675 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34676
34677 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
34678 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
34679 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
34680 if (IS_CV == IS_VAR && !0) {
34681 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
34682 }
34683 return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34684 } else {
34685 zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34686
34687 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
34688 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
34689 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
34690 }
34691 }
34692 break;
34693 default:
34694 value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34695 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34696 /* do nothing */
34697 break;
34698 }
34699
34700 if (UNEXPECTED(var_ptr == NULL)) {
34701 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
34702 }
34703
34704 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
34705 if (RETURN_VALUE_USED(opline)) {
34706 PZVAL_LOCK(&EG(uninitialized_zval));
34707 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
34708 }
34709 zval_dtor(free_op2.var);
34710
34711 CHECK_EXCEPTION();
34712 if (opline->extended_value == ZEND_ASSIGN_DIM) {
34713 ZEND_VM_INC_OPCODE();
34714 }
34715 ZEND_VM_NEXT_OPCODE();
34716 }
34717
34718 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
34719
34720 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
34721 && Z_OBJ_HANDLER_PP(var_ptr, get)
34722 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
34723 /* proxy object */
34724 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
34725 Z_ADDREF_P(objval);
34726 binary_op(objval, objval, value TSRMLS_CC);
34727 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
34728 zval_ptr_dtor(&objval);
34729 } else {
34730 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
34731 }
34732
34733 if (RETURN_VALUE_USED(opline)) {
34734 PZVAL_LOCK(*var_ptr);
34735 EX_T(opline->result.var).var.ptr = *var_ptr;
34736 }
34737 zval_dtor(free_op2.var);
34738
34739 if (opline->extended_value == ZEND_ASSIGN_DIM) {
34740 FREE_OP(free_op_data1);
34741 FREE_OP_VAR_PTR(free_op_data2);
34742
34743 CHECK_EXCEPTION();
34744 ZEND_VM_INC_OPCODE();
34745 } else {
34746
34747 CHECK_EXCEPTION();
34748 }
34749 ZEND_VM_NEXT_OPCODE();
34750 }
34751
ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34752 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34753 {
34754 return zend_binary_assign_op_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34755 }
34756
ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34757 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34758 {
34759 return zend_binary_assign_op_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34760 }
34761
ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34762 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34763 {
34764 return zend_binary_assign_op_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34765 }
34766
ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34767 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34768 {
34769 return zend_binary_assign_op_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34770 }
34771
ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34772 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34773 {
34774 return zend_binary_assign_op_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34775 }
34776
ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34777 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34778 {
34779 return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34780 }
34781
ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34782 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34783 {
34784 return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34785 }
34786
ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34787 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34788 {
34789 return zend_binary_assign_op_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34790 }
34791
ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34792 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34793 {
34794 return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34795 }
34796
ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34797 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34798 {
34799 return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34800 }
34801
ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34802 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34803 {
34804 return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34805 }
34806
zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)34807 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
34808 {
34809 USE_OPLINE
34810 zend_free_op free_op2;
34811 zval **object_ptr;
34812 zval *object;
34813 zval *property;
34814 zval **retval;
34815 int have_get_ptr = 0;
34816
34817 SAVE_OPLINE();
34818 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34819 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34820 retval = &EX_T(opline->result.var).var.ptr;
34821
34822 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
34823 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
34824 }
34825
34826 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
34827 object = *object_ptr;
34828
34829 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34830 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
34831 zval_dtor(free_op2.var);
34832 if (RETURN_VALUE_USED(opline)) {
34833 PZVAL_LOCK(&EG(uninitialized_zval));
34834 *retval = &EG(uninitialized_zval);
34835 }
34836
34837 CHECK_EXCEPTION();
34838 ZEND_VM_NEXT_OPCODE();
34839 }
34840
34841 /* here we are sure we are dealing with an object */
34842
34843 if (1) {
34844 MAKE_REAL_ZVAL_PTR(property);
34845 }
34846
34847 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
34848 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34849 if (zptr != NULL) { /* NULL means no success in getting PTR */
34850 have_get_ptr = 1;
34851 if (UNEXPECTED(*zptr == &EG(error_zval))) {
34852 if (RETURN_VALUE_USED(opline)) {
34853 PZVAL_LOCK(&EG(uninitialized_zval));
34854 *retval = &EG(uninitialized_zval);
34855 }
34856 } else {
34857 SEPARATE_ZVAL_IF_NOT_REF(zptr);
34858
34859 incdec_op(*zptr);
34860 if (RETURN_VALUE_USED(opline)) {
34861 *retval = *zptr;
34862 PZVAL_LOCK(*retval);
34863 }
34864 }
34865 }
34866 }
34867
34868 if (!have_get_ptr) {
34869 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
34870 zval *z;
34871
34872 Z_ADDREF_P(object);
34873 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34874
34875 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
34876 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
34877
34878 if (Z_REFCOUNT_P(z) == 0) {
34879 GC_REMOVE_ZVAL_FROM_BUFFER(z);
34880 zval_dtor(z);
34881 FREE_ZVAL(z);
34882 }
34883 z = value;
34884 }
34885 Z_ADDREF_P(z);
34886 SEPARATE_ZVAL_IF_NOT_REF(&z);
34887 incdec_op(z);
34888 *retval = z;
34889 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34890 zval_ptr_dtor(&object);
34891 SELECTIVE_PZVAL_LOCK(*retval, opline);
34892 zval_ptr_dtor(&z);
34893 } else {
34894 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
34895 if (RETURN_VALUE_USED(opline)) {
34896 PZVAL_LOCK(&EG(uninitialized_zval));
34897 *retval = &EG(uninitialized_zval);
34898 }
34899 }
34900 }
34901
34902 if (1) {
34903 zval_ptr_dtor(&property);
34904 } else {
34905 zval_dtor(free_op2.var);
34906 }
34907
34908 CHECK_EXCEPTION();
34909 ZEND_VM_NEXT_OPCODE();
34910 }
34911
ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34912 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34913 {
34914 return zend_pre_incdec_property_helper_SPEC_CV_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34915 }
34916
ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34917 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34918 {
34919 return zend_pre_incdec_property_helper_SPEC_CV_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34920 }
34921
zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)34922 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
34923 {
34924 USE_OPLINE
34925 zend_free_op free_op2;
34926 zval **object_ptr;
34927 zval *object;
34928 zval *property;
34929 zval *retval;
34930 int have_get_ptr = 0;
34931
34932 SAVE_OPLINE();
34933 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34934 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34935 retval = &EX_T(opline->result.var).tmp_var;
34936
34937 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
34938 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
34939 }
34940
34941 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
34942 object = *object_ptr;
34943
34944 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34945 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
34946 zval_dtor(free_op2.var);
34947 ZVAL_NULL(retval);
34948
34949 CHECK_EXCEPTION();
34950 ZEND_VM_NEXT_OPCODE();
34951 }
34952
34953 /* here we are sure we are dealing with an object */
34954
34955 if (1) {
34956 MAKE_REAL_ZVAL_PTR(property);
34957 }
34958
34959 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
34960 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34961 if (zptr != NULL) { /* NULL means no success in getting PTR */
34962 have_get_ptr = 1;
34963 if (UNEXPECTED(*zptr == &EG(error_zval))) {
34964 ZVAL_NULL(retval);
34965 } else {
34966 SEPARATE_ZVAL_IF_NOT_REF(zptr);
34967
34968 ZVAL_COPY_VALUE(retval, *zptr);
34969 zendi_zval_copy_ctor(*retval);
34970
34971 incdec_op(*zptr);
34972 }
34973 }
34974 }
34975
34976 if (!have_get_ptr) {
34977 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
34978 zval *z, *z_copy;
34979
34980 Z_ADDREF_P(object);
34981 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34982 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
34983 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
34984
34985 if (Z_REFCOUNT_P(z) == 0) {
34986 GC_REMOVE_ZVAL_FROM_BUFFER(z);
34987 zval_dtor(z);
34988 FREE_ZVAL(z);
34989 }
34990 z = value;
34991 }
34992 ZVAL_COPY_VALUE(retval, z);
34993 zendi_zval_copy_ctor(*retval);
34994 ALLOC_ZVAL(z_copy);
34995 INIT_PZVAL_COPY(z_copy, z);
34996 zendi_zval_copy_ctor(*z_copy);
34997 incdec_op(z_copy);
34998 Z_ADDREF_P(z);
34999 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35000 zval_ptr_dtor(&object);
35001 zval_ptr_dtor(&z_copy);
35002 zval_ptr_dtor(&z);
35003 } else {
35004 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
35005 ZVAL_NULL(retval);
35006 }
35007 }
35008
35009 if (1) {
35010 zval_ptr_dtor(&property);
35011 } else {
35012 zval_dtor(free_op2.var);
35013 }
35014
35015 CHECK_EXCEPTION();
35016 ZEND_VM_NEXT_OPCODE();
35017 }
35018
ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35019 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35020 {
35021 return zend_post_incdec_property_helper_SPEC_CV_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
35022 }
35023
ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35024 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35025 {
35026 return zend_post_incdec_property_helper_SPEC_CV_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
35027 }
35028
ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35029 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35030 {
35031 USE_OPLINE
35032 zend_free_op free_op2;
35033 zval *container;
35034
35035 SAVE_OPLINE();
35036 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
35037 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
35038 zval_dtor(free_op2.var);
35039 if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
35040
35041 }
35042 CHECK_EXCEPTION();
35043 ZEND_VM_NEXT_OPCODE();
35044 }
35045
ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35046 static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35047 {
35048 USE_OPLINE
35049 zend_free_op free_op1, free_op2;
35050 zval **container;
35051
35052 SAVE_OPLINE();
35053 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35054
35055 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35056 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
35057 }
35058 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
35059 zval_dtor(free_op2.var);
35060 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35061 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35062 }
35063
35064 /* We are going to assign the result by reference */
35065 if (UNEXPECTED(opline->extended_value != 0)) {
35066 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
35067
35068 if (retval_ptr) {
35069 Z_DELREF_PP(retval_ptr);
35070 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
35071 Z_ADDREF_PP(retval_ptr);
35072 }
35073 }
35074
35075 CHECK_EXCEPTION();
35076 ZEND_VM_NEXT_OPCODE();
35077 }
35078
ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35079 static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35080 {
35081 USE_OPLINE
35082 zend_free_op free_op1, free_op2;
35083 zval **container;
35084
35085 SAVE_OPLINE();
35086 container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
35087
35088 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35089 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
35090 }
35091 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
35092 zval_dtor(free_op2.var);
35093 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35094 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35095 }
35096
35097 CHECK_EXCEPTION();
35098 ZEND_VM_NEXT_OPCODE();
35099 }
35100
ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35101 static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35102 {
35103 USE_OPLINE
35104 zend_free_op free_op2;
35105 zval *container;
35106
35107 SAVE_OPLINE();
35108 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
35109 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC);
35110 zval_dtor(free_op2.var);
35111
35112 CHECK_EXCEPTION();
35113 ZEND_VM_NEXT_OPCODE();
35114 }
35115
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35116 static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35117 {
35118 USE_OPLINE
35119 zend_free_op free_op1, free_op2;
35120
35121 SAVE_OPLINE();
35122
35123 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
35124 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35125 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35126 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
35127 }
35128 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
35129 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35130 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35131 }
35132 zval_dtor(free_op2.var);
35133
35134 } else {
35135 zval *container;
35136
35137 if (IS_TMP_VAR == IS_UNUSED) {
35138 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
35139 }
35140 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
35141 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
35142 zval_dtor(free_op2.var);
35143
35144 }
35145 CHECK_EXCEPTION();
35146 ZEND_VM_NEXT_OPCODE();
35147 }
35148
ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35149 static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35150 {
35151 USE_OPLINE
35152 zend_free_op free_op1, free_op2;
35153 zval **container;
35154
35155 SAVE_OPLINE();
35156 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
35157
35158 if (IS_CV == IS_CV) {
35159 if (container != &EG(uninitialized_zval_ptr)) {
35160 SEPARATE_ZVAL_IF_NOT_REF(container);
35161 }
35162 }
35163 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35164 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
35165 }
35166 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_UNSET TSRMLS_CC);
35167 zval_dtor(free_op2.var);
35168 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35169 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35170 }
35171
35172 if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
35173 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
35174 ZEND_VM_NEXT_OPCODE();
35175 } else {
35176 zend_free_op free_res;
35177 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
35178
35179 PZVAL_UNLOCK(*retval_ptr, &free_res);
35180 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
35181 SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
35182 }
35183 PZVAL_LOCK(*retval_ptr);
35184 FREE_OP_VAR_PTR(free_res);
35185 CHECK_EXCEPTION();
35186 ZEND_VM_NEXT_OPCODE();
35187 }
35188 }
35189
zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS)35190 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS)
35191 {
35192 USE_OPLINE
35193
35194 zval *container;
35195 zend_free_op free_op2;
35196 zval *offset;
35197
35198 SAVE_OPLINE();
35199 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
35200 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35201
35202 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
35203 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
35204 zend_error(E_NOTICE, "Trying to get property of non-object");
35205 PZVAL_LOCK(&EG(uninitialized_zval));
35206 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35207 zval_dtor(free_op2.var);
35208 } else {
35209 zval *retval;
35210
35211 if (1) {
35212 MAKE_REAL_ZVAL_PTR(offset);
35213 }
35214
35215 /* here we are sure we are dealing with an object */
35216 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35217
35218 PZVAL_LOCK(retval);
35219 EX_T(opline->result.var).var.ptr = retval;
35220
35221 if (1) {
35222 zval_ptr_dtor(&offset);
35223 } else {
35224 zval_dtor(free_op2.var);
35225 }
35226 }
35227
35228 CHECK_EXCEPTION();
35229 ZEND_VM_NEXT_OPCODE();
35230 }
35231
ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35232 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35233 {
35234 return zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
35235 }
35236
ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35237 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35238 {
35239 USE_OPLINE
35240 zend_free_op free_op1, free_op2;
35241 zval *property;
35242 zval **container;
35243
35244 SAVE_OPLINE();
35245 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35246
35247 if (1) {
35248 MAKE_REAL_ZVAL_PTR(property);
35249 }
35250 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35251 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35252 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
35253 }
35254
35255 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
35256 if (1) {
35257 zval_ptr_dtor(&property);
35258 } else {
35259 zval_dtor(free_op2.var);
35260 }
35261 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35262 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35263 }
35264
35265 /* We are going to assign the result by reference */
35266 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
35267 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
35268
35269 Z_DELREF_PP(retval_ptr);
35270 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
35271 Z_ADDREF_PP(retval_ptr);
35272 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
35273 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
35274 }
35275
35276 CHECK_EXCEPTION();
35277 ZEND_VM_NEXT_OPCODE();
35278 }
35279
ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35280 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35281 {
35282 USE_OPLINE
35283 zend_free_op free_op1, free_op2;
35284 zval *property;
35285 zval **container;
35286
35287 SAVE_OPLINE();
35288 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35289 container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
35290
35291 if (1) {
35292 MAKE_REAL_ZVAL_PTR(property);
35293 }
35294 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35295 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
35296 }
35297 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
35298 if (1) {
35299 zval_ptr_dtor(&property);
35300 } else {
35301 zval_dtor(free_op2.var);
35302 }
35303 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35304 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35305 }
35306
35307 CHECK_EXCEPTION();
35308 ZEND_VM_NEXT_OPCODE();
35309 }
35310
ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35311 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35312 {
35313 USE_OPLINE
35314
35315 zval *container;
35316 zend_free_op free_op2;
35317 zval *offset;
35318
35319 SAVE_OPLINE();
35320 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
35321 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35322
35323 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
35324 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
35325 PZVAL_LOCK(&EG(uninitialized_zval));
35326 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35327 zval_dtor(free_op2.var);
35328 } else {
35329 zval *retval;
35330
35331 if (1) {
35332 MAKE_REAL_ZVAL_PTR(offset);
35333 }
35334
35335 /* here we are sure we are dealing with an object */
35336 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35337
35338 PZVAL_LOCK(retval);
35339 EX_T(opline->result.var).var.ptr = retval;
35340
35341 if (1) {
35342 zval_ptr_dtor(&offset);
35343 } else {
35344 zval_dtor(free_op2.var);
35345 }
35346 }
35347
35348 CHECK_EXCEPTION();
35349 ZEND_VM_NEXT_OPCODE();
35350 }
35351
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35352 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35353 {
35354 USE_OPLINE
35355
35356 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
35357 /* Behave like FETCH_OBJ_W */
35358 zend_free_op free_op1, free_op2;
35359 zval *property;
35360 zval **container;
35361
35362 SAVE_OPLINE();
35363 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35364 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35365
35366 if (1) {
35367 MAKE_REAL_ZVAL_PTR(property);
35368 }
35369 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35370 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
35371 }
35372 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
35373 if (1) {
35374 zval_ptr_dtor(&property);
35375 } else {
35376 zval_dtor(free_op2.var);
35377 }
35378 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35379 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35380 }
35381
35382 CHECK_EXCEPTION();
35383 ZEND_VM_NEXT_OPCODE();
35384 } else {
35385 return zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
35386 }
35387 }
35388
ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35389 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35390 {
35391 USE_OPLINE
35392 zend_free_op free_op1, free_op2, free_res;
35393 zval **container;
35394 zval *property;
35395
35396 SAVE_OPLINE();
35397 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
35398 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35399
35400 if (IS_CV == IS_CV) {
35401 if (container != &EG(uninitialized_zval_ptr)) {
35402 SEPARATE_ZVAL_IF_NOT_REF(container);
35403 }
35404 }
35405 if (1) {
35406 MAKE_REAL_ZVAL_PTR(property);
35407 }
35408 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35409 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
35410 }
35411 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
35412 if (1) {
35413 zval_ptr_dtor(&property);
35414 } else {
35415 zval_dtor(free_op2.var);
35416 }
35417 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35418 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35419 }
35420
35421 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
35422 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
35423 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
35424 }
35425 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
35426 FREE_OP_VAR_PTR(free_res);
35427 CHECK_EXCEPTION();
35428 ZEND_VM_NEXT_OPCODE();
35429 }
35430
ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35431 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35432 {
35433 USE_OPLINE
35434 zend_free_op free_op2;
35435 zval **object_ptr;
35436 zval *property_name;
35437
35438 SAVE_OPLINE();
35439 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35440 property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35441
35442 if (1) {
35443 MAKE_REAL_ZVAL_PTR(property_name);
35444 }
35445 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
35446 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
35447 }
35448 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35449 if (1) {
35450 zval_ptr_dtor(&property_name);
35451 } else {
35452 zval_dtor(free_op2.var);
35453 }
35454
35455 /* assign_obj has two opcodes! */
35456 CHECK_EXCEPTION();
35457 ZEND_VM_INC_OPCODE();
35458 ZEND_VM_NEXT_OPCODE();
35459 }
35460
ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35461 static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35462 {
35463 USE_OPLINE
35464
35465 zval **object_ptr;
35466
35467 SAVE_OPLINE();
35468 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35469
35470 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
35471 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
35472 }
35473 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
35474 zend_free_op free_op2;
35475 zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35476
35477 if (1) {
35478 MAKE_REAL_ZVAL_PTR(property_name);
35479 }
35480 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35481 if (1) {
35482 zval_ptr_dtor(&property_name);
35483 } else {
35484 zval_dtor(free_op2.var);
35485 }
35486 } else {
35487 zend_free_op free_op2, free_op_data1, free_op_data2;
35488 zval *value;
35489 zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35490 zval **variable_ptr_ptr;
35491
35492 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
35493 zval_dtor(free_op2.var);
35494
35495 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
35496 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
35497 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
35498 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
35499 if (RETURN_VALUE_USED(opline)) {
35500 zval *retval;
35501
35502 ALLOC_ZVAL(retval);
35503 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
35504 INIT_PZVAL(retval);
35505 EX_T(opline->result.var).var.ptr = retval;
35506 }
35507 } else if (RETURN_VALUE_USED(opline)) {
35508 PZVAL_LOCK(&EG(uninitialized_zval));
35509 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35510 }
35511 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
35512 if (IS_TMP_FREE(free_op_data1)) {
35513 zval_dtor(value);
35514 }
35515 if (RETURN_VALUE_USED(opline)) {
35516 PZVAL_LOCK(&EG(uninitialized_zval));
35517 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35518 }
35519 } else {
35520 if ((opline+1)->op1_type == IS_TMP_VAR) {
35521 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35522 } else if ((opline+1)->op1_type == IS_CONST) {
35523 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35524 } else {
35525 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35526 }
35527 if (RETURN_VALUE_USED(opline)) {
35528 PZVAL_LOCK(value);
35529 EX_T(opline->result.var).var.ptr = value;
35530 }
35531 }
35532 FREE_OP_VAR_PTR(free_op_data2);
35533 FREE_OP_IF_VAR(free_op_data1);
35534 }
35535
35536 /* assign_dim has two opcodes! */
35537 CHECK_EXCEPTION();
35538 ZEND_VM_INC_OPCODE();
35539 ZEND_VM_NEXT_OPCODE();
35540 }
35541
ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35542 static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35543 {
35544 USE_OPLINE
35545 zend_free_op free_op2;
35546 zval *value;
35547 zval **variable_ptr_ptr;
35548
35549 SAVE_OPLINE();
35550 value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35551 variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35552
35553 if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
35554 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) {
35555 if (RETURN_VALUE_USED(opline)) {
35556 zval *retval;
35557
35558 ALLOC_ZVAL(retval);
35559 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
35560 INIT_PZVAL(retval);
35561 EX_T(opline->result.var).var.ptr = retval;
35562 }
35563 } else if (RETURN_VALUE_USED(opline)) {
35564 PZVAL_LOCK(&EG(uninitialized_zval));
35565 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35566 }
35567 } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
35568 if (1) {
35569 zval_dtor(value);
35570 }
35571 if (RETURN_VALUE_USED(opline)) {
35572 PZVAL_LOCK(&EG(uninitialized_zval));
35573 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35574 }
35575 } else {
35576 if (IS_TMP_VAR == IS_TMP_VAR) {
35577 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35578 } else if (IS_TMP_VAR == IS_CONST) {
35579 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35580 } else {
35581 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35582 }
35583 if (RETURN_VALUE_USED(opline)) {
35584 PZVAL_LOCK(value);
35585 EX_T(opline->result.var).var.ptr = value;
35586 }
35587 }
35588
35589 if (IS_CV == IS_VAR && 0) {
35590 zval_ptr_dtor_nogc(&value);
35591 }
35592
35593 /* zend_assign_to_variable() always takes care of op2, never free it! */
35594
35595 CHECK_EXCEPTION();
35596 ZEND_VM_NEXT_OPCODE();
35597 }
35598
ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35599 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35600 {
35601 USE_OPLINE
35602 zval *function_name;
35603 char *function_name_strval;
35604 int function_name_strlen;
35605 zend_free_op free_op2;
35606 call_slot *call = EX(call_slots) + opline->result.num;
35607
35608 SAVE_OPLINE();
35609
35610 function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35611
35612 if (IS_TMP_VAR != IS_CONST &&
35613 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
35614 if (UNEXPECTED(EG(exception) != NULL)) {
35615 HANDLE_EXCEPTION();
35616 }
35617 zend_error_noreturn(E_ERROR, "Method name must be a string");
35618 }
35619
35620 function_name_strval = Z_STRVAL_P(function_name);
35621 function_name_strlen = Z_STRLEN_P(function_name);
35622
35623 call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
35624
35625 if (EXPECTED(call->object != NULL) &&
35626 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
35627 call->called_scope = Z_OBJCE_P(call->object);
35628
35629 if (IS_TMP_VAR != IS_CONST ||
35630 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
35631 zval *object = call->object;
35632
35633 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
35634 zend_error_noreturn(E_ERROR, "Object does not support method calls");
35635 }
35636
35637 /* First, locate the function. */
35638 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
35639 if (UNEXPECTED(call->fbc == NULL)) {
35640 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
35641 }
35642 if (IS_TMP_VAR == IS_CONST &&
35643 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
35644 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
35645 EXPECTED(call->object == object)) {
35646 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
35647 }
35648 }
35649 } else {
35650 if (UNEXPECTED(EG(exception) != NULL)) {
35651 zval_dtor(free_op2.var);
35652 HANDLE_EXCEPTION();
35653 }
35654 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
35655 }
35656
35657 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
35658 call->object = NULL;
35659 } else {
35660 if (!PZVAL_IS_REF(call->object)) {
35661 Z_ADDREF_P(call->object); /* For $this pointer */
35662 } else {
35663 zval *this_ptr;
35664 ALLOC_ZVAL(this_ptr);
35665 INIT_PZVAL_COPY(this_ptr, call->object);
35666 zval_copy_ctor(this_ptr);
35667 call->object = this_ptr;
35668 }
35669 }
35670
35671 call->num_additional_args = 0;
35672 call->is_ctor_call = 0;
35673 EX(call) = call;
35674
35675 zval_dtor(free_op2.var);
35676
35677 CHECK_EXCEPTION();
35678 ZEND_VM_NEXT_OPCODE();
35679 }
35680
ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35681 static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35682 {
35683 USE_OPLINE
35684 zend_free_op free_op2;
35685
35686 SAVE_OPLINE();
35687 is_equal_function(&EX_T(opline->result.var).tmp_var,
35688 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
35689 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
35690
35691 zval_dtor(free_op2.var);
35692 CHECK_EXCEPTION();
35693 ZEND_VM_NEXT_OPCODE();
35694 }
35695
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35696 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35697 {
35698 USE_OPLINE
35699
35700 zval *expr_ptr;
35701
35702 SAVE_OPLINE();
35703 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
35704 zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35705
35706 if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
35707 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
35708 }
35709 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
35710 expr_ptr = *expr_ptr_ptr;
35711 Z_ADDREF_P(expr_ptr);
35712 } else {
35713 expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
35714 if (0) { /* temporary variable */
35715 zval *new_expr;
35716
35717 ALLOC_ZVAL(new_expr);
35718 INIT_PZVAL_COPY(new_expr, expr_ptr);
35719 expr_ptr = new_expr;
35720 } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
35721 zval *new_expr;
35722
35723 ALLOC_ZVAL(new_expr);
35724 INIT_PZVAL_COPY(new_expr, expr_ptr);
35725 expr_ptr = new_expr;
35726 zendi_zval_copy_ctor(*expr_ptr);
35727
35728 } else if (IS_CV == IS_CV) {
35729 Z_ADDREF_P(expr_ptr);
35730 }
35731 }
35732
35733 if (IS_TMP_VAR != IS_UNUSED) {
35734 zend_free_op free_op2;
35735 zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35736 ulong hval;
35737
35738 switch (Z_TYPE_P(offset)) {
35739 case IS_DOUBLE:
35740 hval = zend_dval_to_lval(Z_DVAL_P(offset));
35741 goto num_index;
35742 case IS_LONG:
35743 case IS_BOOL:
35744 hval = Z_LVAL_P(offset);
35745 num_index:
35746 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
35747 break;
35748 case IS_STRING:
35749 if (IS_TMP_VAR == IS_CONST) {
35750 hval = Z_HASH_P(offset);
35751 } else {
35752 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
35753 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
35754 }
35755 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
35756 break;
35757 case IS_NULL:
35758 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
35759 break;
35760 default:
35761 zend_error(E_WARNING, "Illegal offset type");
35762 zval_ptr_dtor(&expr_ptr);
35763 /* do nothing */
35764 break;
35765 }
35766 zval_dtor(free_op2.var);
35767 } else {
35768 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
35769 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
35770 zval_ptr_dtor(&expr_ptr);
35771 }
35772 }
35773 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
35774
35775 }
35776 CHECK_EXCEPTION();
35777 ZEND_VM_NEXT_OPCODE();
35778 }
35779
ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35780 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35781 {
35782 USE_OPLINE
35783
35784 array_init(&EX_T(opline->result.var).tmp_var);
35785 if (IS_CV == IS_UNUSED) {
35786 ZEND_VM_NEXT_OPCODE();
35787 #if 0 || IS_CV != IS_UNUSED
35788 } else {
35789 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
35790 #endif
35791 }
35792 }
35793
ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35794 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35795 {
35796 USE_OPLINE
35797 zend_free_op free_op2;
35798 zval **container;
35799 zval *offset;
35800 ulong hval;
35801
35802 SAVE_OPLINE();
35803 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
35804 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
35805 SEPARATE_ZVAL_IF_NOT_REF(container);
35806 }
35807 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35808
35809 if (IS_CV != IS_VAR || container) {
35810 switch (Z_TYPE_PP(container)) {
35811 case IS_ARRAY: {
35812 HashTable *ht = Z_ARRVAL_PP(container);
35813
35814 switch (Z_TYPE_P(offset)) {
35815 case IS_DOUBLE:
35816 hval = zend_dval_to_lval(Z_DVAL_P(offset));
35817 zend_hash_index_del(ht, hval);
35818 break;
35819 case IS_RESOURCE:
35820 case IS_BOOL:
35821 case IS_LONG:
35822 hval = Z_LVAL_P(offset);
35823 zend_hash_index_del(ht, hval);
35824 break;
35825 case IS_STRING:
35826 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
35827 Z_ADDREF_P(offset);
35828 }
35829 if (IS_TMP_VAR == IS_CONST) {
35830 hval = Z_HASH_P(offset);
35831 } else {
35832 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
35833 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
35834 }
35835 if (ht == &EG(symbol_table)) {
35836 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
35837 } else {
35838 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
35839 }
35840 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
35841 zval_ptr_dtor(&offset);
35842 }
35843 break;
35844 num_index_dim:
35845 zend_hash_index_del(ht, hval);
35846 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
35847 zval_ptr_dtor(&offset);
35848 }
35849 break;
35850 case IS_NULL:
35851 zend_hash_del(ht, "", sizeof(""));
35852 break;
35853 default:
35854 zend_error(E_WARNING, "Illegal offset type in unset");
35855 break;
35856 }
35857 zval_dtor(free_op2.var);
35858 break;
35859 }
35860 case IS_OBJECT:
35861 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
35862 zend_error_noreturn(E_ERROR, "Cannot use object as array");
35863 }
35864 if (1) {
35865 MAKE_REAL_ZVAL_PTR(offset);
35866 }
35867 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
35868 if (1) {
35869 zval_ptr_dtor(&offset);
35870 } else {
35871 zval_dtor(free_op2.var);
35872 }
35873 break;
35874 case IS_STRING:
35875 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
35876 ZEND_VM_CONTINUE(); /* bailed out before */
35877 default:
35878 zval_dtor(free_op2.var);
35879 break;
35880 }
35881 } else {
35882 zval_dtor(free_op2.var);
35883 }
35884
35885 CHECK_EXCEPTION();
35886 ZEND_VM_NEXT_OPCODE();
35887 }
35888
ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35889 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35890 {
35891 USE_OPLINE
35892 zend_free_op free_op2;
35893 zval **container;
35894 zval *offset;
35895
35896 SAVE_OPLINE();
35897 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
35898 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35899
35900 if (IS_CV != IS_VAR || container) {
35901 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
35902 SEPARATE_ZVAL_IF_NOT_REF(container);
35903 }
35904 if (Z_TYPE_PP(container) == IS_OBJECT) {
35905 if (1) {
35906 MAKE_REAL_ZVAL_PTR(offset);
35907 }
35908 if (Z_OBJ_HT_P(*container)->unset_property) {
35909 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35910 } else {
35911 zend_error(E_NOTICE, "Trying to unset property of non-object");
35912 }
35913 if (1) {
35914 zval_ptr_dtor(&offset);
35915 } else {
35916 zval_dtor(free_op2.var);
35917 }
35918 } else {
35919 zval_dtor(free_op2.var);
35920 }
35921 } else {
35922 zval_dtor(free_op2.var);
35923 }
35924
35925 CHECK_EXCEPTION();
35926 ZEND_VM_NEXT_OPCODE();
35927 }
35928
zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)35929 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
35930 {
35931 USE_OPLINE
35932 zend_free_op free_op2;
35933 zval *container;
35934 zval **value = NULL;
35935 int result = 0;
35936 ulong hval;
35937 zval *offset;
35938
35939 SAVE_OPLINE();
35940 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
35941 offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35942
35943 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
35944 HashTable *ht;
35945 int isset = 0;
35946
35947 ht = Z_ARRVAL_P(container);
35948
35949 switch (Z_TYPE_P(offset)) {
35950 case IS_DOUBLE:
35951 hval = zend_dval_to_lval(Z_DVAL_P(offset));
35952 goto num_index_prop;
35953 case IS_RESOURCE:
35954 case IS_BOOL:
35955 case IS_LONG:
35956 hval = Z_LVAL_P(offset);
35957 num_index_prop:
35958 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
35959 isset = 1;
35960 }
35961 break;
35962 case IS_STRING:
35963 if (IS_TMP_VAR == IS_CONST) {
35964 hval = Z_HASH_P(offset);
35965 } else {
35966 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
35967 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
35968 }
35969 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
35970 isset = 1;
35971 }
35972 break;
35973 case IS_NULL:
35974 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
35975 isset = 1;
35976 }
35977 break;
35978 default:
35979 zend_error(E_WARNING, "Illegal offset type in isset or empty");
35980 break;
35981 }
35982
35983 if (opline->extended_value & ZEND_ISSET) {
35984 if (isset && Z_TYPE_PP(value) == IS_NULL) {
35985 result = 0;
35986 } else {
35987 result = isset;
35988 }
35989 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
35990 if (!isset || !i_zend_is_true(*value)) {
35991 result = 0;
35992 } else {
35993 result = 1;
35994 }
35995 }
35996 zval_dtor(free_op2.var);
35997 } else if (Z_TYPE_P(container) == IS_OBJECT) {
35998 if (1) {
35999 MAKE_REAL_ZVAL_PTR(offset);
36000 }
36001 if (prop_dim) {
36002 if (Z_OBJ_HT_P(container)->has_property) {
36003 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36004 } else {
36005 zend_error(E_NOTICE, "Trying to check property of non-object");
36006 result = 0;
36007 }
36008 } else {
36009 if (Z_OBJ_HT_P(container)->has_dimension) {
36010 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
36011 } else {
36012 zend_error(E_NOTICE, "Trying to check element of non-array");
36013 result = 0;
36014 }
36015 }
36016 if (1) {
36017 zval_ptr_dtor(&offset);
36018 } else {
36019 zval_dtor(free_op2.var);
36020 }
36021 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
36022 zval tmp;
36023
36024 if (Z_TYPE_P(offset) != IS_LONG) {
36025 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
36026 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
36027 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
36028 ZVAL_COPY_VALUE(&tmp, offset);
36029 zval_copy_ctor(&tmp);
36030 convert_to_long(&tmp);
36031 offset = &tmp;
36032 } else {
36033 /* can not be converted to proper offset, return "not set" */
36034 result = 0;
36035 }
36036 }
36037 if (Z_TYPE_P(offset) == IS_LONG) {
36038 if (opline->extended_value & ZEND_ISSET) {
36039 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
36040 result = 1;
36041 }
36042 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
36043 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
36044 result = 1;
36045 }
36046 }
36047 }
36048 zval_dtor(free_op2.var);
36049 } else {
36050 zval_dtor(free_op2.var);
36051 }
36052
36053 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
36054 if (opline->extended_value & ZEND_ISSET) {
36055 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
36056 } else {
36057 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
36058 }
36059
36060 CHECK_EXCEPTION();
36061 ZEND_VM_NEXT_OPCODE();
36062 }
36063
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36064 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36065 {
36066 return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36067 }
36068
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36069 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36070 {
36071 return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36072 }
36073
ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36074 static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36075 {
36076 USE_OPLINE
36077
36078 /* The generator object is stored in return_value_ptr_ptr */
36079 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
36080
36081 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
36082 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
36083 }
36084
36085 /* Destroy the previously yielded value */
36086 if (generator->value) {
36087 zval_ptr_dtor(&generator->value);
36088 }
36089
36090 /* Destroy the previously yielded key */
36091 if (generator->key) {
36092 zval_ptr_dtor(&generator->key);
36093 }
36094
36095 /* Set the new yielded value */
36096 if (IS_CV != IS_UNUSED) {
36097
36098
36099 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
36100 /* Constants and temporary variables aren't yieldable by reference,
36101 * but we still allow them with a notice. */
36102 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
36103 zval *value, *copy;
36104
36105 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
36106
36107 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
36108 ALLOC_ZVAL(copy);
36109 INIT_PZVAL_COPY(copy, value);
36110
36111 /* Temporary variables don't need ctor copying */
36112 if (!0) {
36113 zval_copy_ctor(copy);
36114 }
36115
36116 generator->value = copy;
36117 } else {
36118 zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
36119
36120 if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
36121 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
36122 }
36123
36124 /* If a function call result is yielded and the function did
36125 * not return by reference we throw a notice. */
36126 if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
36127 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
36128 && EX_T(opline->op1.var).var.fcall_returned_reference)
36129 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
36130 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
36131
36132 Z_ADDREF_PP(value_ptr);
36133 generator->value = *value_ptr;
36134 } else {
36135 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
36136 Z_ADDREF_PP(value_ptr);
36137 generator->value = *value_ptr;
36138 }
36139
36140 }
36141 } else {
36142 zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
36143
36144 /* Consts, temporary variables and references need copying */
36145 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
36146 || PZVAL_IS_REF(value)
36147 ) {
36148 zval *copy;
36149
36150 ALLOC_ZVAL(copy);
36151 INIT_PZVAL_COPY(copy, value);
36152
36153 /* Temporary variables don't need ctor copying */
36154 if (!0) {
36155 zval_copy_ctor(copy);
36156 }
36157
36158 generator->value = copy;
36159
36160 } else {
36161 if (IS_CV == IS_CV) {
36162 Z_ADDREF_P(value);
36163 }
36164 generator->value = value;
36165 }
36166 }
36167 } else {
36168 /* If no value was specified yield null */
36169 Z_ADDREF(EG(uninitialized_zval));
36170 generator->value = &EG(uninitialized_zval);
36171 }
36172
36173 /* Set the new yielded key */
36174 if (IS_TMP_VAR != IS_UNUSED) {
36175 zend_free_op free_op2;
36176 zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36177
36178 /* Consts, temporary variables and references need copying */
36179 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
36180 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
36181 ) {
36182 zval *copy;
36183
36184 ALLOC_ZVAL(copy);
36185 INIT_PZVAL_COPY(copy, key);
36186
36187 /* Temporary variables don't need ctor copying */
36188 if (!1) {
36189 zval_copy_ctor(copy);
36190 }
36191
36192 generator->key = copy;
36193 } else {
36194 Z_ADDREF_P(key);
36195 generator->key = key;
36196 }
36197
36198 if (Z_TYPE_P(generator->key) == IS_LONG
36199 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
36200 ) {
36201 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
36202 }
36203
36204 } else {
36205 /* If no key was specified we use auto-increment keys */
36206 generator->largest_used_integer_key++;
36207
36208 ALLOC_INIT_ZVAL(generator->key);
36209 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
36210 }
36211
36212 if (RETURN_VALUE_USED(opline)) {
36213 /* If the return value of yield is used set the send
36214 * target and initialize it to NULL */
36215 generator->send_target = &EX_T(opline->result.var).var.ptr;
36216 Z_ADDREF(EG(uninitialized_zval));
36217 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
36218 } else {
36219 generator->send_target = NULL;
36220 }
36221
36222 /* We increment to the next op, so we are at the correct position when the
36223 * generator is resumed. */
36224 ZEND_VM_INC_OPCODE();
36225
36226 /* The GOTO VM uses a local opline variable. We need to set the opline
36227 * variable in execute_data so we don't resume at an old position. */
36228 SAVE_OPLINE();
36229
36230 ZEND_VM_RETURN();
36231 }
36232
ZEND_POW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36233 static int ZEND_FASTCALL ZEND_POW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36234 {
36235 USE_OPLINE
36236 zend_free_op free_op2;
36237
36238 SAVE_OPLINE();
36239 pow_function(&EX_T(opline->result.var).tmp_var,
36240 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36241 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36242
36243 zval_dtor(free_op2.var);
36244 CHECK_EXCEPTION();
36245 ZEND_VM_NEXT_OPCODE();
36246 }
36247
ZEND_ASSIGN_POW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36248 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36249 {
36250 return zend_binary_assign_op_helper_SPEC_CV_TMP(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36251 }
36252
ZEND_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36253 static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36254 {
36255 USE_OPLINE
36256 zend_free_op free_op2;
36257
36258 SAVE_OPLINE();
36259 fast_add_function(&EX_T(opline->result.var).tmp_var,
36260 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36261 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36262
36263 zval_ptr_dtor_nogc(&free_op2.var);
36264 CHECK_EXCEPTION();
36265 ZEND_VM_NEXT_OPCODE();
36266 }
36267
ZEND_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36268 static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36269 {
36270 USE_OPLINE
36271 zend_free_op free_op2;
36272
36273 SAVE_OPLINE();
36274 fast_sub_function(&EX_T(opline->result.var).tmp_var,
36275 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36276 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36277
36278 zval_ptr_dtor_nogc(&free_op2.var);
36279 CHECK_EXCEPTION();
36280 ZEND_VM_NEXT_OPCODE();
36281 }
36282
ZEND_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36283 static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36284 {
36285 USE_OPLINE
36286 zend_free_op free_op2;
36287
36288 SAVE_OPLINE();
36289 fast_mul_function(&EX_T(opline->result.var).tmp_var,
36290 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36291 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36292
36293 zval_ptr_dtor_nogc(&free_op2.var);
36294 CHECK_EXCEPTION();
36295 ZEND_VM_NEXT_OPCODE();
36296 }
36297
ZEND_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36298 static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36299 {
36300 USE_OPLINE
36301 zend_free_op free_op2;
36302
36303 SAVE_OPLINE();
36304 fast_div_function(&EX_T(opline->result.var).tmp_var,
36305 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36306 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36307
36308 zval_ptr_dtor_nogc(&free_op2.var);
36309 CHECK_EXCEPTION();
36310 ZEND_VM_NEXT_OPCODE();
36311 }
36312
ZEND_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36313 static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36314 {
36315 USE_OPLINE
36316 zend_free_op free_op2;
36317
36318 SAVE_OPLINE();
36319 fast_mod_function(&EX_T(opline->result.var).tmp_var,
36320 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36321 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36322
36323 zval_ptr_dtor_nogc(&free_op2.var);
36324 CHECK_EXCEPTION();
36325 ZEND_VM_NEXT_OPCODE();
36326 }
36327
ZEND_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36328 static int ZEND_FASTCALL ZEND_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36329 {
36330 USE_OPLINE
36331 zend_free_op free_op2;
36332
36333 SAVE_OPLINE();
36334 shift_left_function(&EX_T(opline->result.var).tmp_var,
36335 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36336 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36337
36338 zval_ptr_dtor_nogc(&free_op2.var);
36339 CHECK_EXCEPTION();
36340 ZEND_VM_NEXT_OPCODE();
36341 }
36342
ZEND_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36343 static int ZEND_FASTCALL ZEND_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36344 {
36345 USE_OPLINE
36346 zend_free_op free_op2;
36347
36348 SAVE_OPLINE();
36349 shift_right_function(&EX_T(opline->result.var).tmp_var,
36350 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36351 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36352
36353 zval_ptr_dtor_nogc(&free_op2.var);
36354 CHECK_EXCEPTION();
36355 ZEND_VM_NEXT_OPCODE();
36356 }
36357
ZEND_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36358 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36359 {
36360 USE_OPLINE
36361 zend_free_op free_op2;
36362
36363 SAVE_OPLINE();
36364 concat_function(&EX_T(opline->result.var).tmp_var,
36365 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36366 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36367
36368 zval_ptr_dtor_nogc(&free_op2.var);
36369 CHECK_EXCEPTION();
36370 ZEND_VM_NEXT_OPCODE();
36371 }
36372
ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36373 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36374 {
36375 USE_OPLINE
36376 zend_free_op free_op2;
36377
36378 SAVE_OPLINE();
36379 is_identical_function(&EX_T(opline->result.var).tmp_var,
36380 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36381 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36382
36383 zval_ptr_dtor_nogc(&free_op2.var);
36384 CHECK_EXCEPTION();
36385 ZEND_VM_NEXT_OPCODE();
36386 }
36387
ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36388 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36389 {
36390 USE_OPLINE
36391 zend_free_op free_op2;
36392 zval *result = &EX_T(opline->result.var).tmp_var;
36393
36394 SAVE_OPLINE();
36395 is_identical_function(result,
36396 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36397 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36398 Z_LVAL_P(result) = !Z_LVAL_P(result);
36399
36400 zval_ptr_dtor_nogc(&free_op2.var);
36401 CHECK_EXCEPTION();
36402 ZEND_VM_NEXT_OPCODE();
36403 }
36404
ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36405 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36406 {
36407 USE_OPLINE
36408 zend_free_op free_op2;
36409 zval *result = &EX_T(opline->result.var).tmp_var;
36410
36411 SAVE_OPLINE();
36412 ZVAL_BOOL(result, fast_equal_function(result,
36413 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36414 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
36415
36416 zval_ptr_dtor_nogc(&free_op2.var);
36417 CHECK_EXCEPTION();
36418 ZEND_VM_NEXT_OPCODE();
36419 }
36420
ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36421 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36422 {
36423 USE_OPLINE
36424 zend_free_op free_op2;
36425 zval *result = &EX_T(opline->result.var).tmp_var;
36426
36427 SAVE_OPLINE();
36428 ZVAL_BOOL(result, fast_not_equal_function(result,
36429 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36430 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
36431
36432 zval_ptr_dtor_nogc(&free_op2.var);
36433 CHECK_EXCEPTION();
36434 ZEND_VM_NEXT_OPCODE();
36435 }
36436
ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36437 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36438 {
36439 USE_OPLINE
36440 zend_free_op free_op2;
36441 zval *result = &EX_T(opline->result.var).tmp_var;
36442
36443 SAVE_OPLINE();
36444 ZVAL_BOOL(result, fast_is_smaller_function(result,
36445 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36446 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
36447
36448 zval_ptr_dtor_nogc(&free_op2.var);
36449 CHECK_EXCEPTION();
36450 ZEND_VM_NEXT_OPCODE();
36451 }
36452
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36453 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36454 {
36455 USE_OPLINE
36456 zend_free_op free_op2;
36457 zval *result = &EX_T(opline->result.var).tmp_var;
36458
36459 SAVE_OPLINE();
36460 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
36461 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36462 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
36463
36464 zval_ptr_dtor_nogc(&free_op2.var);
36465 CHECK_EXCEPTION();
36466 ZEND_VM_NEXT_OPCODE();
36467 }
36468
ZEND_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36469 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36470 {
36471 USE_OPLINE
36472 zend_free_op free_op2;
36473
36474 SAVE_OPLINE();
36475 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
36476 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36477 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36478
36479 zval_ptr_dtor_nogc(&free_op2.var);
36480 CHECK_EXCEPTION();
36481 ZEND_VM_NEXT_OPCODE();
36482 }
36483
ZEND_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36484 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36485 {
36486 USE_OPLINE
36487 zend_free_op free_op2;
36488
36489 SAVE_OPLINE();
36490 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
36491 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36492 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36493
36494 zval_ptr_dtor_nogc(&free_op2.var);
36495 CHECK_EXCEPTION();
36496 ZEND_VM_NEXT_OPCODE();
36497 }
36498
ZEND_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36499 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36500 {
36501 USE_OPLINE
36502 zend_free_op free_op2;
36503
36504 SAVE_OPLINE();
36505 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
36506 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36507 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36508
36509 zval_ptr_dtor_nogc(&free_op2.var);
36510 CHECK_EXCEPTION();
36511 ZEND_VM_NEXT_OPCODE();
36512 }
36513
ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36514 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36515 {
36516 USE_OPLINE
36517 zend_free_op free_op2;
36518
36519 SAVE_OPLINE();
36520 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
36521 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36522 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36523
36524 zval_ptr_dtor_nogc(&free_op2.var);
36525 CHECK_EXCEPTION();
36526 ZEND_VM_NEXT_OPCODE();
36527 }
36528
zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)36529 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
36530 {
36531 USE_OPLINE
36532 zend_free_op free_op2, free_op_data1;
36533 zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36534 zval *object;
36535 zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36536 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
36537 int have_get_ptr = 0;
36538
36539 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
36540 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
36541 }
36542
36543 make_real_object(object_ptr TSRMLS_CC);
36544 object = *object_ptr;
36545
36546 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36547 zend_error(E_WARNING, "Attempt to assign property of non-object");
36548 zval_ptr_dtor_nogc(&free_op2.var);
36549 FREE_OP(free_op_data1);
36550
36551 if (RETURN_VALUE_USED(opline)) {
36552 PZVAL_LOCK(&EG(uninitialized_zval));
36553 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
36554 }
36555 } else {
36556 /* here we are sure we are dealing with an object */
36557 if (0) {
36558 MAKE_REAL_ZVAL_PTR(property);
36559 }
36560
36561 /* here property is a string */
36562 if (opline->extended_value == ZEND_ASSIGN_OBJ
36563 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
36564 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36565 if (zptr != NULL) { /* NULL means no success in getting PTR */
36566 have_get_ptr = 1;
36567 if (UNEXPECTED(*zptr == &EG(error_zval))) {
36568 if (RETURN_VALUE_USED(opline)) {
36569 PZVAL_LOCK(&EG(uninitialized_zval));
36570 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
36571 }
36572 } else {
36573 SEPARATE_ZVAL_IF_NOT_REF(zptr);
36574
36575 binary_op(*zptr, *zptr, value TSRMLS_CC);
36576 if (RETURN_VALUE_USED(opline)) {
36577 PZVAL_LOCK(*zptr);
36578 EX_T(opline->result.var).var.ptr = *zptr;
36579 }
36580 }
36581 }
36582 }
36583
36584 if (!have_get_ptr) {
36585 zval *z = NULL;
36586
36587 Z_ADDREF_P(object);
36588 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
36589 if (Z_OBJ_HT_P(object)->read_property) {
36590 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36591 }
36592 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
36593 if (Z_OBJ_HT_P(object)->read_dimension) {
36594 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
36595 }
36596 }
36597 if (z) {
36598 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
36599 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
36600
36601 if (Z_REFCOUNT_P(z) == 0) {
36602 GC_REMOVE_ZVAL_FROM_BUFFER(z);
36603 zval_dtor(z);
36604 FREE_ZVAL(z);
36605 }
36606 z = value;
36607 }
36608 Z_ADDREF_P(z);
36609 SEPARATE_ZVAL_IF_NOT_REF(&z);
36610 binary_op(z, z, value TSRMLS_CC);
36611 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
36612 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36613 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
36614 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
36615 }
36616 if (RETURN_VALUE_USED(opline)) {
36617 PZVAL_LOCK(z);
36618 EX_T(opline->result.var).var.ptr = z;
36619 }
36620 zval_ptr_dtor(&z);
36621 } else {
36622 zend_error(E_WARNING, "Attempt to assign property of non-object");
36623 if (RETURN_VALUE_USED(opline)) {
36624 PZVAL_LOCK(&EG(uninitialized_zval));
36625 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
36626 }
36627 }
36628 zval_ptr_dtor(&object);
36629 }
36630
36631 if (0) {
36632 zval_ptr_dtor(&property);
36633 } else {
36634 zval_ptr_dtor_nogc(&free_op2.var);
36635 }
36636 FREE_OP(free_op_data1);
36637 }
36638
36639 /* assign_obj has two opcodes! */
36640 CHECK_EXCEPTION();
36641 ZEND_VM_INC_OPCODE();
36642 ZEND_VM_NEXT_OPCODE();
36643 }
36644
zend_binary_assign_op_helper_SPEC_CV_VAR(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)36645 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
36646 {
36647 USE_OPLINE
36648 zend_free_op free_op2, free_op_data2, free_op_data1;
36649 zval **var_ptr;
36650 zval *value;
36651
36652 SAVE_OPLINE();
36653 switch (opline->extended_value) {
36654 case ZEND_ASSIGN_OBJ:
36655 return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36656 break;
36657 case ZEND_ASSIGN_DIM: {
36658 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36659
36660 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
36661 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
36662 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
36663 if (IS_CV == IS_VAR && !0) {
36664 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
36665 }
36666 return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36667 } else {
36668 zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36669
36670 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC);
36671 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
36672 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
36673 }
36674 }
36675 break;
36676 default:
36677 value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36678 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36679 /* do nothing */
36680 break;
36681 }
36682
36683 if (UNEXPECTED(var_ptr == NULL)) {
36684 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
36685 }
36686
36687 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
36688 if (RETURN_VALUE_USED(opline)) {
36689 PZVAL_LOCK(&EG(uninitialized_zval));
36690 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
36691 }
36692 zval_ptr_dtor_nogc(&free_op2.var);
36693
36694 CHECK_EXCEPTION();
36695 if (opline->extended_value == ZEND_ASSIGN_DIM) {
36696 ZEND_VM_INC_OPCODE();
36697 }
36698 ZEND_VM_NEXT_OPCODE();
36699 }
36700
36701 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
36702
36703 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
36704 && Z_OBJ_HANDLER_PP(var_ptr, get)
36705 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
36706 /* proxy object */
36707 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
36708 Z_ADDREF_P(objval);
36709 binary_op(objval, objval, value TSRMLS_CC);
36710 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
36711 zval_ptr_dtor(&objval);
36712 } else {
36713 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
36714 }
36715
36716 if (RETURN_VALUE_USED(opline)) {
36717 PZVAL_LOCK(*var_ptr);
36718 EX_T(opline->result.var).var.ptr = *var_ptr;
36719 }
36720 zval_ptr_dtor_nogc(&free_op2.var);
36721
36722 if (opline->extended_value == ZEND_ASSIGN_DIM) {
36723 FREE_OP(free_op_data1);
36724 FREE_OP_VAR_PTR(free_op_data2);
36725
36726 CHECK_EXCEPTION();
36727 ZEND_VM_INC_OPCODE();
36728 } else {
36729
36730 CHECK_EXCEPTION();
36731 }
36732 ZEND_VM_NEXT_OPCODE();
36733 }
36734
ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36735 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36736 {
36737 return zend_binary_assign_op_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36738 }
36739
ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36740 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36741 {
36742 return zend_binary_assign_op_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36743 }
36744
ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36745 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36746 {
36747 return zend_binary_assign_op_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36748 }
36749
ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36750 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36751 {
36752 return zend_binary_assign_op_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36753 }
36754
ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36755 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36756 {
36757 return zend_binary_assign_op_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36758 }
36759
ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36760 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36761 {
36762 return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36763 }
36764
ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36765 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36766 {
36767 return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36768 }
36769
ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36770 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36771 {
36772 return zend_binary_assign_op_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36773 }
36774
ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36775 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36776 {
36777 return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36778 }
36779
ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36780 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36781 {
36782 return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36783 }
36784
ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36785 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36786 {
36787 return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36788 }
36789
zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)36790 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
36791 {
36792 USE_OPLINE
36793 zend_free_op free_op2;
36794 zval **object_ptr;
36795 zval *object;
36796 zval *property;
36797 zval **retval;
36798 int have_get_ptr = 0;
36799
36800 SAVE_OPLINE();
36801 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36802 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36803 retval = &EX_T(opline->result.var).var.ptr;
36804
36805 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
36806 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
36807 }
36808
36809 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
36810 object = *object_ptr;
36811
36812 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36813 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
36814 zval_ptr_dtor_nogc(&free_op2.var);
36815 if (RETURN_VALUE_USED(opline)) {
36816 PZVAL_LOCK(&EG(uninitialized_zval));
36817 *retval = &EG(uninitialized_zval);
36818 }
36819
36820 CHECK_EXCEPTION();
36821 ZEND_VM_NEXT_OPCODE();
36822 }
36823
36824 /* here we are sure we are dealing with an object */
36825
36826 if (0) {
36827 MAKE_REAL_ZVAL_PTR(property);
36828 }
36829
36830 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
36831 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36832 if (zptr != NULL) { /* NULL means no success in getting PTR */
36833 have_get_ptr = 1;
36834 if (UNEXPECTED(*zptr == &EG(error_zval))) {
36835 if (RETURN_VALUE_USED(opline)) {
36836 PZVAL_LOCK(&EG(uninitialized_zval));
36837 *retval = &EG(uninitialized_zval);
36838 }
36839 } else {
36840 SEPARATE_ZVAL_IF_NOT_REF(zptr);
36841
36842 incdec_op(*zptr);
36843 if (RETURN_VALUE_USED(opline)) {
36844 *retval = *zptr;
36845 PZVAL_LOCK(*retval);
36846 }
36847 }
36848 }
36849 }
36850
36851 if (!have_get_ptr) {
36852 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
36853 zval *z;
36854
36855 Z_ADDREF_P(object);
36856 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36857
36858 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
36859 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
36860
36861 if (Z_REFCOUNT_P(z) == 0) {
36862 GC_REMOVE_ZVAL_FROM_BUFFER(z);
36863 zval_dtor(z);
36864 FREE_ZVAL(z);
36865 }
36866 z = value;
36867 }
36868 Z_ADDREF_P(z);
36869 SEPARATE_ZVAL_IF_NOT_REF(&z);
36870 incdec_op(z);
36871 *retval = z;
36872 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36873 zval_ptr_dtor(&object);
36874 SELECTIVE_PZVAL_LOCK(*retval, opline);
36875 zval_ptr_dtor(&z);
36876 } else {
36877 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
36878 if (RETURN_VALUE_USED(opline)) {
36879 PZVAL_LOCK(&EG(uninitialized_zval));
36880 *retval = &EG(uninitialized_zval);
36881 }
36882 }
36883 }
36884
36885 if (0) {
36886 zval_ptr_dtor(&property);
36887 } else {
36888 zval_ptr_dtor_nogc(&free_op2.var);
36889 }
36890
36891 CHECK_EXCEPTION();
36892 ZEND_VM_NEXT_OPCODE();
36893 }
36894
ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36895 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36896 {
36897 return zend_pre_incdec_property_helper_SPEC_CV_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36898 }
36899
ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36900 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36901 {
36902 return zend_pre_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36903 }
36904
zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)36905 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
36906 {
36907 USE_OPLINE
36908 zend_free_op free_op2;
36909 zval **object_ptr;
36910 zval *object;
36911 zval *property;
36912 zval *retval;
36913 int have_get_ptr = 0;
36914
36915 SAVE_OPLINE();
36916 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36917 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36918 retval = &EX_T(opline->result.var).tmp_var;
36919
36920 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
36921 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
36922 }
36923
36924 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
36925 object = *object_ptr;
36926
36927 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36928 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
36929 zval_ptr_dtor_nogc(&free_op2.var);
36930 ZVAL_NULL(retval);
36931
36932 CHECK_EXCEPTION();
36933 ZEND_VM_NEXT_OPCODE();
36934 }
36935
36936 /* here we are sure we are dealing with an object */
36937
36938 if (0) {
36939 MAKE_REAL_ZVAL_PTR(property);
36940 }
36941
36942 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
36943 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36944 if (zptr != NULL) { /* NULL means no success in getting PTR */
36945 have_get_ptr = 1;
36946 if (UNEXPECTED(*zptr == &EG(error_zval))) {
36947 ZVAL_NULL(retval);
36948 } else {
36949 SEPARATE_ZVAL_IF_NOT_REF(zptr);
36950
36951 ZVAL_COPY_VALUE(retval, *zptr);
36952 zendi_zval_copy_ctor(*retval);
36953
36954 incdec_op(*zptr);
36955 }
36956 }
36957 }
36958
36959 if (!have_get_ptr) {
36960 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
36961 zval *z, *z_copy;
36962
36963 Z_ADDREF_P(object);
36964 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36965 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
36966 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
36967
36968 if (Z_REFCOUNT_P(z) == 0) {
36969 GC_REMOVE_ZVAL_FROM_BUFFER(z);
36970 zval_dtor(z);
36971 FREE_ZVAL(z);
36972 }
36973 z = value;
36974 }
36975 ZVAL_COPY_VALUE(retval, z);
36976 zendi_zval_copy_ctor(*retval);
36977 ALLOC_ZVAL(z_copy);
36978 INIT_PZVAL_COPY(z_copy, z);
36979 zendi_zval_copy_ctor(*z_copy);
36980 incdec_op(z_copy);
36981 Z_ADDREF_P(z);
36982 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36983 zval_ptr_dtor(&object);
36984 zval_ptr_dtor(&z_copy);
36985 zval_ptr_dtor(&z);
36986 } else {
36987 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
36988 ZVAL_NULL(retval);
36989 }
36990 }
36991
36992 if (0) {
36993 zval_ptr_dtor(&property);
36994 } else {
36995 zval_ptr_dtor_nogc(&free_op2.var);
36996 }
36997
36998 CHECK_EXCEPTION();
36999 ZEND_VM_NEXT_OPCODE();
37000 }
37001
ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37002 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37003 {
37004 return zend_post_incdec_property_helper_SPEC_CV_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37005 }
37006
ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37007 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37008 {
37009 return zend_post_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37010 }
37011
zend_fetch_var_address_helper_SPEC_CV_VAR(int type,ZEND_OPCODE_HANDLER_ARGS)37012 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
37013 {
37014 USE_OPLINE
37015 zend_free_op free_op1;
37016 zval *varname;
37017 zval **retval;
37018 zval tmp_varname;
37019 HashTable *target_symbol_table;
37020 ulong hash_value;
37021
37022 SAVE_OPLINE();
37023 varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37024
37025 if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
37026 ZVAL_COPY_VALUE(&tmp_varname, varname);
37027 zval_copy_ctor(&tmp_varname);
37028 Z_SET_REFCOUNT(tmp_varname, 1);
37029 Z_UNSET_ISREF(tmp_varname);
37030 convert_to_string(&tmp_varname);
37031 varname = &tmp_varname;
37032 }
37033
37034 if (IS_VAR != IS_UNUSED) {
37035 zend_class_entry *ce;
37036
37037 if (IS_VAR == IS_CONST) {
37038 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
37039 ce = CACHED_PTR(opline->op2.literal->cache_slot);
37040 } else {
37041 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
37042 if (UNEXPECTED(ce == NULL)) {
37043 if (IS_CV != IS_CONST && varname == &tmp_varname) {
37044 zval_dtor(&tmp_varname);
37045 }
37046
37047 CHECK_EXCEPTION();
37048 ZEND_VM_NEXT_OPCODE();
37049 }
37050 CACHE_PTR(opline->op2.literal->cache_slot, ce);
37051 }
37052 } else {
37053 ce = EX_T(opline->op2.var).class_entry;
37054 }
37055 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
37056
37057 } else {
37058 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
37059 /*
37060 if (!target_symbol_table) {
37061 CHECK_EXCEPTION();
37062 ZEND_VM_NEXT_OPCODE();
37063 }
37064 */
37065 if (IS_CV == IS_CONST) {
37066 hash_value = Z_HASH_P(varname);
37067 } else {
37068 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
37069 }
37070
37071 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
37072 switch (type) {
37073 case BP_VAR_R:
37074 case BP_VAR_UNSET:
37075 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
37076 /* break missing intentionally */
37077 case BP_VAR_IS:
37078 retval = &EG(uninitialized_zval_ptr);
37079 break;
37080 case BP_VAR_RW:
37081 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
37082 /* break missing intentionally */
37083 case BP_VAR_W:
37084 Z_ADDREF_P(&EG(uninitialized_zval));
37085 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
37086 break;
37087 EMPTY_SWITCH_DEFAULT_CASE()
37088 }
37089 }
37090 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
37091 case ZEND_FETCH_GLOBAL:
37092 if (IS_CV != IS_TMP_VAR) {
37093
37094 }
37095 break;
37096 case ZEND_FETCH_LOCAL:
37097
37098 break;
37099 case ZEND_FETCH_STATIC:
37100 zval_update_constant(retval, 1 TSRMLS_CC);
37101 break;
37102 case ZEND_FETCH_GLOBAL_LOCK:
37103 if (IS_CV == IS_VAR && !free_op1.var) {
37104 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
37105 }
37106 break;
37107 }
37108 }
37109
37110
37111 if (IS_CV != IS_CONST && varname == &tmp_varname) {
37112 zval_dtor(&tmp_varname);
37113 }
37114 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
37115 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
37116 }
37117 PZVAL_LOCK(*retval);
37118 switch (type) {
37119 case BP_VAR_R:
37120 case BP_VAR_IS:
37121 EX_T(opline->result.var).var.ptr = *retval;
37122 break;
37123 case BP_VAR_UNSET: {
37124 zend_free_op free_res;
37125
37126 PZVAL_UNLOCK(*retval, &free_res);
37127 if (retval != &EG(uninitialized_zval_ptr)) {
37128 SEPARATE_ZVAL_IF_NOT_REF(retval);
37129 }
37130 PZVAL_LOCK(*retval);
37131 FREE_OP_VAR_PTR(free_res);
37132 }
37133 /* break missing intentionally */
37134 default:
37135 EX_T(opline->result.var).var.ptr_ptr = retval;
37136 break;
37137 }
37138 CHECK_EXCEPTION();
37139 ZEND_VM_NEXT_OPCODE();
37140 }
37141
ZEND_FETCH_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37142 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37143 {
37144 return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37145 }
37146
ZEND_FETCH_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37147 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37148 {
37149 return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37150 }
37151
ZEND_FETCH_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37152 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37153 {
37154 return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37155 }
37156
ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37157 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37158 {
37159 USE_OPLINE
37160
37161 return zend_fetch_var_address_helper_SPEC_CV_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37162 }
37163
ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37164 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37165 {
37166 return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37167 }
37168
ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37169 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37170 {
37171 return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37172 }
37173
ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37174 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37175 {
37176 USE_OPLINE
37177 zend_free_op free_op2;
37178 zval *container;
37179
37180 SAVE_OPLINE();
37181 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37182 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
37183 zval_ptr_dtor_nogc(&free_op2.var);
37184 if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
37185
37186 }
37187 CHECK_EXCEPTION();
37188 ZEND_VM_NEXT_OPCODE();
37189 }
37190
ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37191 static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37192 {
37193 USE_OPLINE
37194 zend_free_op free_op1, free_op2;
37195 zval **container;
37196
37197 SAVE_OPLINE();
37198 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37199
37200 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37201 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
37202 }
37203 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
37204 zval_ptr_dtor_nogc(&free_op2.var);
37205 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37206 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37207 }
37208
37209 /* We are going to assign the result by reference */
37210 if (UNEXPECTED(opline->extended_value != 0)) {
37211 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
37212
37213 if (retval_ptr) {
37214 Z_DELREF_PP(retval_ptr);
37215 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
37216 Z_ADDREF_PP(retval_ptr);
37217 }
37218 }
37219
37220 CHECK_EXCEPTION();
37221 ZEND_VM_NEXT_OPCODE();
37222 }
37223
ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37224 static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37225 {
37226 USE_OPLINE
37227 zend_free_op free_op1, free_op2;
37228 zval **container;
37229
37230 SAVE_OPLINE();
37231 container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
37232
37233 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37234 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
37235 }
37236 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC);
37237 zval_ptr_dtor_nogc(&free_op2.var);
37238 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37239 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37240 }
37241
37242 CHECK_EXCEPTION();
37243 ZEND_VM_NEXT_OPCODE();
37244 }
37245
ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37246 static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37247 {
37248 USE_OPLINE
37249 zend_free_op free_op2;
37250 zval *container;
37251
37252 SAVE_OPLINE();
37253 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
37254 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC);
37255 zval_ptr_dtor_nogc(&free_op2.var);
37256
37257 CHECK_EXCEPTION();
37258 ZEND_VM_NEXT_OPCODE();
37259 }
37260
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37261 static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37262 {
37263 USE_OPLINE
37264 zend_free_op free_op1, free_op2;
37265
37266 SAVE_OPLINE();
37267
37268 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
37269 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37270 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37271 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
37272 }
37273 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
37274 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37275 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37276 }
37277 zval_ptr_dtor_nogc(&free_op2.var);
37278
37279 } else {
37280 zval *container;
37281
37282 if (IS_VAR == IS_UNUSED) {
37283 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
37284 }
37285 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37286 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
37287 zval_ptr_dtor_nogc(&free_op2.var);
37288
37289 }
37290 CHECK_EXCEPTION();
37291 ZEND_VM_NEXT_OPCODE();
37292 }
37293
ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37294 static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37295 {
37296 USE_OPLINE
37297 zend_free_op free_op1, free_op2;
37298 zval **container;
37299
37300 SAVE_OPLINE();
37301 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
37302
37303 if (IS_CV == IS_CV) {
37304 if (container != &EG(uninitialized_zval_ptr)) {
37305 SEPARATE_ZVAL_IF_NOT_REF(container);
37306 }
37307 }
37308 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37309 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
37310 }
37311 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_UNSET TSRMLS_CC);
37312 zval_ptr_dtor_nogc(&free_op2.var);
37313 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37314 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37315 }
37316
37317 if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
37318 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
37319 ZEND_VM_NEXT_OPCODE();
37320 } else {
37321 zend_free_op free_res;
37322 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
37323
37324 PZVAL_UNLOCK(*retval_ptr, &free_res);
37325 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
37326 SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
37327 }
37328 PZVAL_LOCK(*retval_ptr);
37329 FREE_OP_VAR_PTR(free_res);
37330 CHECK_EXCEPTION();
37331 ZEND_VM_NEXT_OPCODE();
37332 }
37333 }
37334
zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS)37335 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS)
37336 {
37337 USE_OPLINE
37338
37339 zval *container;
37340 zend_free_op free_op2;
37341 zval *offset;
37342
37343 SAVE_OPLINE();
37344 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37345 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37346
37347 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
37348 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
37349 zend_error(E_NOTICE, "Trying to get property of non-object");
37350 PZVAL_LOCK(&EG(uninitialized_zval));
37351 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37352 zval_ptr_dtor_nogc(&free_op2.var);
37353 } else {
37354 zval *retval;
37355
37356 if (0) {
37357 MAKE_REAL_ZVAL_PTR(offset);
37358 }
37359
37360 /* here we are sure we are dealing with an object */
37361 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
37362
37363 PZVAL_LOCK(retval);
37364 EX_T(opline->result.var).var.ptr = retval;
37365
37366 if (0) {
37367 zval_ptr_dtor(&offset);
37368 } else {
37369 zval_ptr_dtor_nogc(&free_op2.var);
37370 }
37371 }
37372
37373 CHECK_EXCEPTION();
37374 ZEND_VM_NEXT_OPCODE();
37375 }
37376
ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37377 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37378 {
37379 return zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37380 }
37381
ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37382 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37383 {
37384 USE_OPLINE
37385 zend_free_op free_op1, free_op2;
37386 zval *property;
37387 zval **container;
37388
37389 SAVE_OPLINE();
37390 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37391
37392 if (0) {
37393 MAKE_REAL_ZVAL_PTR(property);
37394 }
37395 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37396 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37397 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
37398 }
37399
37400 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
37401 if (0) {
37402 zval_ptr_dtor(&property);
37403 } else {
37404 zval_ptr_dtor_nogc(&free_op2.var);
37405 }
37406 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37407 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37408 }
37409
37410 /* We are going to assign the result by reference */
37411 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
37412 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
37413
37414 Z_DELREF_PP(retval_ptr);
37415 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
37416 Z_ADDREF_PP(retval_ptr);
37417 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
37418 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
37419 }
37420
37421 CHECK_EXCEPTION();
37422 ZEND_VM_NEXT_OPCODE();
37423 }
37424
ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37425 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37426 {
37427 USE_OPLINE
37428 zend_free_op free_op1, free_op2;
37429 zval *property;
37430 zval **container;
37431
37432 SAVE_OPLINE();
37433 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37434 container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
37435
37436 if (0) {
37437 MAKE_REAL_ZVAL_PTR(property);
37438 }
37439 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37440 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
37441 }
37442 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
37443 if (0) {
37444 zval_ptr_dtor(&property);
37445 } else {
37446 zval_ptr_dtor_nogc(&free_op2.var);
37447 }
37448 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37449 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37450 }
37451
37452 CHECK_EXCEPTION();
37453 ZEND_VM_NEXT_OPCODE();
37454 }
37455
ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37456 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37457 {
37458 USE_OPLINE
37459
37460 zval *container;
37461 zend_free_op free_op2;
37462 zval *offset;
37463
37464 SAVE_OPLINE();
37465 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
37466 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37467
37468 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
37469 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
37470 PZVAL_LOCK(&EG(uninitialized_zval));
37471 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37472 zval_ptr_dtor_nogc(&free_op2.var);
37473 } else {
37474 zval *retval;
37475
37476 if (0) {
37477 MAKE_REAL_ZVAL_PTR(offset);
37478 }
37479
37480 /* here we are sure we are dealing with an object */
37481 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
37482
37483 PZVAL_LOCK(retval);
37484 EX_T(opline->result.var).var.ptr = retval;
37485
37486 if (0) {
37487 zval_ptr_dtor(&offset);
37488 } else {
37489 zval_ptr_dtor_nogc(&free_op2.var);
37490 }
37491 }
37492
37493 CHECK_EXCEPTION();
37494 ZEND_VM_NEXT_OPCODE();
37495 }
37496
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37497 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37498 {
37499 USE_OPLINE
37500
37501 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
37502 /* Behave like FETCH_OBJ_W */
37503 zend_free_op free_op1, free_op2;
37504 zval *property;
37505 zval **container;
37506
37507 SAVE_OPLINE();
37508 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37509 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37510
37511 if (0) {
37512 MAKE_REAL_ZVAL_PTR(property);
37513 }
37514 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37515 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
37516 }
37517 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
37518 if (0) {
37519 zval_ptr_dtor(&property);
37520 } else {
37521 zval_ptr_dtor_nogc(&free_op2.var);
37522 }
37523 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37524 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37525 }
37526
37527 CHECK_EXCEPTION();
37528 ZEND_VM_NEXT_OPCODE();
37529 } else {
37530 return zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37531 }
37532 }
37533
ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37534 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37535 {
37536 USE_OPLINE
37537 zend_free_op free_op1, free_op2, free_res;
37538 zval **container;
37539 zval *property;
37540
37541 SAVE_OPLINE();
37542 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
37543 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37544
37545 if (IS_CV == IS_CV) {
37546 if (container != &EG(uninitialized_zval_ptr)) {
37547 SEPARATE_ZVAL_IF_NOT_REF(container);
37548 }
37549 }
37550 if (0) {
37551 MAKE_REAL_ZVAL_PTR(property);
37552 }
37553 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37554 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
37555 }
37556 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
37557 if (0) {
37558 zval_ptr_dtor(&property);
37559 } else {
37560 zval_ptr_dtor_nogc(&free_op2.var);
37561 }
37562 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37563 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37564 }
37565
37566 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
37567 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
37568 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
37569 }
37570 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
37571 FREE_OP_VAR_PTR(free_res);
37572 CHECK_EXCEPTION();
37573 ZEND_VM_NEXT_OPCODE();
37574 }
37575
ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37576 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37577 {
37578 USE_OPLINE
37579 zend_free_op free_op2;
37580 zval **object_ptr;
37581 zval *property_name;
37582
37583 SAVE_OPLINE();
37584 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37585 property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37586
37587 if (0) {
37588 MAKE_REAL_ZVAL_PTR(property_name);
37589 }
37590 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
37591 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
37592 }
37593 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
37594 if (0) {
37595 zval_ptr_dtor(&property_name);
37596 } else {
37597 zval_ptr_dtor_nogc(&free_op2.var);
37598 }
37599
37600 /* assign_obj has two opcodes! */
37601 CHECK_EXCEPTION();
37602 ZEND_VM_INC_OPCODE();
37603 ZEND_VM_NEXT_OPCODE();
37604 }
37605
ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37606 static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37607 {
37608 USE_OPLINE
37609
37610 zval **object_ptr;
37611
37612 SAVE_OPLINE();
37613 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37614
37615 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
37616 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
37617 }
37618 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
37619 zend_free_op free_op2;
37620 zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37621
37622 if (0) {
37623 MAKE_REAL_ZVAL_PTR(property_name);
37624 }
37625 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
37626 if (0) {
37627 zval_ptr_dtor(&property_name);
37628 } else {
37629 zval_ptr_dtor_nogc(&free_op2.var);
37630 }
37631 } else {
37632 zend_free_op free_op2, free_op_data1, free_op_data2;
37633 zval *value;
37634 zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37635 zval **variable_ptr_ptr;
37636
37637 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_VAR, BP_VAR_W TSRMLS_CC);
37638 zval_ptr_dtor_nogc(&free_op2.var);
37639
37640 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
37641 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
37642 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
37643 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
37644 if (RETURN_VALUE_USED(opline)) {
37645 zval *retval;
37646
37647 ALLOC_ZVAL(retval);
37648 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
37649 INIT_PZVAL(retval);
37650 EX_T(opline->result.var).var.ptr = retval;
37651 }
37652 } else if (RETURN_VALUE_USED(opline)) {
37653 PZVAL_LOCK(&EG(uninitialized_zval));
37654 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37655 }
37656 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
37657 if (IS_TMP_FREE(free_op_data1)) {
37658 zval_dtor(value);
37659 }
37660 if (RETURN_VALUE_USED(opline)) {
37661 PZVAL_LOCK(&EG(uninitialized_zval));
37662 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37663 }
37664 } else {
37665 if ((opline+1)->op1_type == IS_TMP_VAR) {
37666 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37667 } else if ((opline+1)->op1_type == IS_CONST) {
37668 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37669 } else {
37670 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37671 }
37672 if (RETURN_VALUE_USED(opline)) {
37673 PZVAL_LOCK(value);
37674 EX_T(opline->result.var).var.ptr = value;
37675 }
37676 }
37677 FREE_OP_VAR_PTR(free_op_data2);
37678 FREE_OP_IF_VAR(free_op_data1);
37679 }
37680
37681 /* assign_dim has two opcodes! */
37682 CHECK_EXCEPTION();
37683 ZEND_VM_INC_OPCODE();
37684 ZEND_VM_NEXT_OPCODE();
37685 }
37686
ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37687 static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37688 {
37689 USE_OPLINE
37690 zend_free_op free_op2;
37691 zval *value;
37692 zval **variable_ptr_ptr;
37693
37694 SAVE_OPLINE();
37695 value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37696 variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37697
37698 if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
37699 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_VAR TSRMLS_CC)) {
37700 if (RETURN_VALUE_USED(opline)) {
37701 zval *retval;
37702
37703 ALLOC_ZVAL(retval);
37704 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
37705 INIT_PZVAL(retval);
37706 EX_T(opline->result.var).var.ptr = retval;
37707 }
37708 } else if (RETURN_VALUE_USED(opline)) {
37709 PZVAL_LOCK(&EG(uninitialized_zval));
37710 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37711 }
37712 } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
37713 if (0) {
37714 zval_dtor(value);
37715 }
37716 if (RETURN_VALUE_USED(opline)) {
37717 PZVAL_LOCK(&EG(uninitialized_zval));
37718 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37719 }
37720 } else {
37721 if (IS_VAR == IS_TMP_VAR) {
37722 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37723 } else if (IS_VAR == IS_CONST) {
37724 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37725 } else {
37726 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37727 }
37728 if (RETURN_VALUE_USED(opline)) {
37729 PZVAL_LOCK(value);
37730 EX_T(opline->result.var).var.ptr = value;
37731 }
37732 }
37733
37734 if (IS_CV == IS_VAR && 0) {
37735 zval_ptr_dtor_nogc(&value);
37736 }
37737
37738 /* zend_assign_to_variable() always takes care of op2, never free it! */
37739 zval_ptr_dtor_nogc(&free_op2.var);
37740
37741 CHECK_EXCEPTION();
37742 ZEND_VM_NEXT_OPCODE();
37743 }
37744
ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37745 static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37746 {
37747 USE_OPLINE
37748 zend_free_op free_op2;
37749 zval **variable_ptr_ptr;
37750 zval **value_ptr_ptr;
37751
37752 SAVE_OPLINE();
37753 value_ptr_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37754
37755 if (IS_CV == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
37756 zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
37757 }
37758
37759 if (IS_VAR == IS_VAR &&
37760 value_ptr_ptr &&
37761 !Z_ISREF_PP(value_ptr_ptr) &&
37762 opline->extended_value == ZEND_RETURNS_FUNCTION &&
37763 !EX_T(opline->op2.var).var.fcall_returned_reference) {
37764 if (free_op2.var == NULL) {
37765 PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
37766 }
37767 zend_error(E_STRICT, "Only variables should be assigned by reference");
37768 if (UNEXPECTED(EG(exception) != NULL)) {
37769 if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
37770 HANDLE_EXCEPTION();
37771 }
37772 return ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37773 } else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
37774 PZVAL_LOCK(*value_ptr_ptr);
37775 }
37776
37777 variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37778 if ((IS_VAR == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
37779 (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
37780 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
37781 } else if ((IS_VAR == IS_VAR && UNEXPECTED(*value_ptr_ptr == &EG(error_zval))) ||
37782 (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval)))) {
37783 variable_ptr_ptr = &EG(uninitialized_zval_ptr);
37784 } else {
37785 zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
37786 if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
37787 Z_DELREF_PP(variable_ptr_ptr);
37788 }
37789 }
37790
37791 if (RETURN_VALUE_USED(opline)) {
37792 PZVAL_LOCK(*variable_ptr_ptr);
37793 EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
37794 }
37795
37796 if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
37797
37798 CHECK_EXCEPTION();
37799 ZEND_VM_NEXT_OPCODE();
37800 }
37801
ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37802 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37803 {
37804 USE_OPLINE
37805 zval *function_name;
37806 char *function_name_strval;
37807 int function_name_strlen;
37808 zend_free_op free_op2;
37809 call_slot *call = EX(call_slots) + opline->result.num;
37810
37811 SAVE_OPLINE();
37812
37813 function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37814
37815 if (IS_VAR != IS_CONST &&
37816 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37817 if (UNEXPECTED(EG(exception) != NULL)) {
37818 HANDLE_EXCEPTION();
37819 }
37820 zend_error_noreturn(E_ERROR, "Method name must be a string");
37821 }
37822
37823 function_name_strval = Z_STRVAL_P(function_name);
37824 function_name_strlen = Z_STRLEN_P(function_name);
37825
37826 call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37827
37828 if (EXPECTED(call->object != NULL) &&
37829 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
37830 call->called_scope = Z_OBJCE_P(call->object);
37831
37832 if (IS_VAR != IS_CONST ||
37833 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
37834 zval *object = call->object;
37835
37836 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
37837 zend_error_noreturn(E_ERROR, "Object does not support method calls");
37838 }
37839
37840 /* First, locate the function. */
37841 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
37842 if (UNEXPECTED(call->fbc == NULL)) {
37843 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
37844 }
37845 if (IS_VAR == IS_CONST &&
37846 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
37847 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
37848 EXPECTED(call->object == object)) {
37849 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
37850 }
37851 }
37852 } else {
37853 if (UNEXPECTED(EG(exception) != NULL)) {
37854 zval_ptr_dtor_nogc(&free_op2.var);
37855 HANDLE_EXCEPTION();
37856 }
37857 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
37858 }
37859
37860 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
37861 call->object = NULL;
37862 } else {
37863 if (!PZVAL_IS_REF(call->object)) {
37864 Z_ADDREF_P(call->object); /* For $this pointer */
37865 } else {
37866 zval *this_ptr;
37867 ALLOC_ZVAL(this_ptr);
37868 INIT_PZVAL_COPY(this_ptr, call->object);
37869 zval_copy_ctor(this_ptr);
37870 call->object = this_ptr;
37871 }
37872 }
37873
37874 call->num_additional_args = 0;
37875 call->is_ctor_call = 0;
37876 EX(call) = call;
37877
37878 zval_ptr_dtor_nogc(&free_op2.var);
37879
37880 CHECK_EXCEPTION();
37881 ZEND_VM_NEXT_OPCODE();
37882 }
37883
ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37884 static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37885 {
37886 USE_OPLINE
37887 zend_free_op free_op2;
37888
37889 SAVE_OPLINE();
37890 is_equal_function(&EX_T(opline->result.var).tmp_var,
37891 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
37892 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
37893
37894 zval_ptr_dtor_nogc(&free_op2.var);
37895 CHECK_EXCEPTION();
37896 ZEND_VM_NEXT_OPCODE();
37897 }
37898
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37899 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37900 {
37901 USE_OPLINE
37902
37903 zval *expr_ptr;
37904
37905 SAVE_OPLINE();
37906 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
37907 zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37908
37909 if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
37910 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
37911 }
37912 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
37913 expr_ptr = *expr_ptr_ptr;
37914 Z_ADDREF_P(expr_ptr);
37915 } else {
37916 expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37917 if (0) { /* temporary variable */
37918 zval *new_expr;
37919
37920 ALLOC_ZVAL(new_expr);
37921 INIT_PZVAL_COPY(new_expr, expr_ptr);
37922 expr_ptr = new_expr;
37923 } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
37924 zval *new_expr;
37925
37926 ALLOC_ZVAL(new_expr);
37927 INIT_PZVAL_COPY(new_expr, expr_ptr);
37928 expr_ptr = new_expr;
37929 zendi_zval_copy_ctor(*expr_ptr);
37930
37931 } else if (IS_CV == IS_CV) {
37932 Z_ADDREF_P(expr_ptr);
37933 }
37934 }
37935
37936 if (IS_VAR != IS_UNUSED) {
37937 zend_free_op free_op2;
37938 zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37939 ulong hval;
37940
37941 switch (Z_TYPE_P(offset)) {
37942 case IS_DOUBLE:
37943 hval = zend_dval_to_lval(Z_DVAL_P(offset));
37944 goto num_index;
37945 case IS_LONG:
37946 case IS_BOOL:
37947 hval = Z_LVAL_P(offset);
37948 num_index:
37949 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
37950 break;
37951 case IS_STRING:
37952 if (IS_VAR == IS_CONST) {
37953 hval = Z_HASH_P(offset);
37954 } else {
37955 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
37956 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
37957 }
37958 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
37959 break;
37960 case IS_NULL:
37961 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
37962 break;
37963 default:
37964 zend_error(E_WARNING, "Illegal offset type");
37965 zval_ptr_dtor(&expr_ptr);
37966 /* do nothing */
37967 break;
37968 }
37969 zval_ptr_dtor_nogc(&free_op2.var);
37970 } else {
37971 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
37972 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
37973 zval_ptr_dtor(&expr_ptr);
37974 }
37975 }
37976 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
37977
37978 }
37979 CHECK_EXCEPTION();
37980 ZEND_VM_NEXT_OPCODE();
37981 }
37982
ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37983 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37984 {
37985 USE_OPLINE
37986
37987 array_init(&EX_T(opline->result.var).tmp_var);
37988 if (IS_CV == IS_UNUSED) {
37989 ZEND_VM_NEXT_OPCODE();
37990 #if 0 || IS_CV != IS_UNUSED
37991 } else {
37992 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37993 #endif
37994 }
37995 }
37996
ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37997 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37998 {
37999 USE_OPLINE
38000 zval tmp, *varname;
38001 HashTable *target_symbol_table;
38002
38003
38004 SAVE_OPLINE();
38005 if (IS_CV == IS_CV &&
38006 IS_VAR == IS_UNUSED &&
38007 (opline->extended_value & ZEND_QUICK_SET)) {
38008 if (EG(active_symbol_table)) {
38009 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
38010
38011 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
38012 EX_CV(opline->op1.var) = NULL;
38013 } else if (EX_CV(opline->op1.var)) {
38014 zval_ptr_dtor(EX_CV(opline->op1.var));
38015 EX_CV(opline->op1.var) = NULL;
38016 }
38017 CHECK_EXCEPTION();
38018 ZEND_VM_NEXT_OPCODE();
38019 }
38020
38021 varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
38022
38023 if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
38024 ZVAL_COPY_VALUE(&tmp, varname);
38025 zval_copy_ctor(&tmp);
38026 convert_to_string(&tmp);
38027 varname = &tmp;
38028 } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
38029 Z_ADDREF_P(varname);
38030 }
38031
38032 if (IS_VAR != IS_UNUSED) {
38033 zend_class_entry *ce;
38034
38035 if (IS_VAR == IS_CONST) {
38036 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
38037 ce = CACHED_PTR(opline->op2.literal->cache_slot);
38038 } else {
38039 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
38040 if (UNEXPECTED(EG(exception) != NULL)) {
38041 if (IS_CV != IS_CONST && varname == &tmp) {
38042 zval_dtor(&tmp);
38043 } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
38044 zval_ptr_dtor(&varname);
38045 }
38046
38047 HANDLE_EXCEPTION();
38048 }
38049 if (UNEXPECTED(ce == NULL)) {
38050 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
38051 }
38052 CACHE_PTR(opline->op2.literal->cache_slot, ce);
38053 }
38054 } else {
38055 ce = EX_T(opline->op2.var).class_entry;
38056 }
38057 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
38058 } else {
38059 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
38060
38061 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
38062 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
38063 }
38064
38065 if (IS_CV != IS_CONST && varname == &tmp) {
38066 zval_dtor(&tmp);
38067 } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
38068 zval_ptr_dtor(&varname);
38069 }
38070
38071 CHECK_EXCEPTION();
38072 ZEND_VM_NEXT_OPCODE();
38073 }
38074
ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38075 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38076 {
38077 USE_OPLINE
38078 zend_free_op free_op2;
38079 zval **container;
38080 zval *offset;
38081 ulong hval;
38082
38083 SAVE_OPLINE();
38084 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
38085 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
38086 SEPARATE_ZVAL_IF_NOT_REF(container);
38087 }
38088 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
38089
38090 if (IS_CV != IS_VAR || container) {
38091 switch (Z_TYPE_PP(container)) {
38092 case IS_ARRAY: {
38093 HashTable *ht = Z_ARRVAL_PP(container);
38094
38095 switch (Z_TYPE_P(offset)) {
38096 case IS_DOUBLE:
38097 hval = zend_dval_to_lval(Z_DVAL_P(offset));
38098 zend_hash_index_del(ht, hval);
38099 break;
38100 case IS_RESOURCE:
38101 case IS_BOOL:
38102 case IS_LONG:
38103 hval = Z_LVAL_P(offset);
38104 zend_hash_index_del(ht, hval);
38105 break;
38106 case IS_STRING:
38107 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
38108 Z_ADDREF_P(offset);
38109 }
38110 if (IS_VAR == IS_CONST) {
38111 hval = Z_HASH_P(offset);
38112 } else {
38113 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
38114 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
38115 }
38116 if (ht == &EG(symbol_table)) {
38117 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
38118 } else {
38119 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
38120 }
38121 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
38122 zval_ptr_dtor(&offset);
38123 }
38124 break;
38125 num_index_dim:
38126 zend_hash_index_del(ht, hval);
38127 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
38128 zval_ptr_dtor(&offset);
38129 }
38130 break;
38131 case IS_NULL:
38132 zend_hash_del(ht, "", sizeof(""));
38133 break;
38134 default:
38135 zend_error(E_WARNING, "Illegal offset type in unset");
38136 break;
38137 }
38138 zval_ptr_dtor_nogc(&free_op2.var);
38139 break;
38140 }
38141 case IS_OBJECT:
38142 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
38143 zend_error_noreturn(E_ERROR, "Cannot use object as array");
38144 }
38145 if (0) {
38146 MAKE_REAL_ZVAL_PTR(offset);
38147 }
38148 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
38149 if (0) {
38150 zval_ptr_dtor(&offset);
38151 } else {
38152 zval_ptr_dtor_nogc(&free_op2.var);
38153 }
38154 break;
38155 case IS_STRING:
38156 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
38157 ZEND_VM_CONTINUE(); /* bailed out before */
38158 default:
38159 zval_ptr_dtor_nogc(&free_op2.var);
38160 break;
38161 }
38162 } else {
38163 zval_ptr_dtor_nogc(&free_op2.var);
38164 }
38165
38166 CHECK_EXCEPTION();
38167 ZEND_VM_NEXT_OPCODE();
38168 }
38169
ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38170 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38171 {
38172 USE_OPLINE
38173 zend_free_op free_op2;
38174 zval **container;
38175 zval *offset;
38176
38177 SAVE_OPLINE();
38178 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
38179 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
38180
38181 if (IS_CV != IS_VAR || container) {
38182 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
38183 SEPARATE_ZVAL_IF_NOT_REF(container);
38184 }
38185 if (Z_TYPE_PP(container) == IS_OBJECT) {
38186 if (0) {
38187 MAKE_REAL_ZVAL_PTR(offset);
38188 }
38189 if (Z_OBJ_HT_P(*container)->unset_property) {
38190 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
38191 } else {
38192 zend_error(E_NOTICE, "Trying to unset property of non-object");
38193 }
38194 if (0) {
38195 zval_ptr_dtor(&offset);
38196 } else {
38197 zval_ptr_dtor_nogc(&free_op2.var);
38198 }
38199 } else {
38200 zval_ptr_dtor_nogc(&free_op2.var);
38201 }
38202 } else {
38203 zval_ptr_dtor_nogc(&free_op2.var);
38204 }
38205
38206 CHECK_EXCEPTION();
38207 ZEND_VM_NEXT_OPCODE();
38208 }
38209
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38210 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38211 {
38212 USE_OPLINE
38213 zval **value;
38214 zend_bool isset = 1;
38215
38216 SAVE_OPLINE();
38217 if (IS_CV == IS_CV &&
38218 IS_VAR == IS_UNUSED &&
38219 (opline->extended_value & ZEND_QUICK_SET)) {
38220 if (EX_CV(opline->op1.var)) {
38221 value = EX_CV(opline->op1.var);
38222 } else if (EG(active_symbol_table)) {
38223 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
38224
38225 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
38226 isset = 0;
38227 }
38228 } else {
38229 isset = 0;
38230 }
38231 } else {
38232 HashTable *target_symbol_table;
38233
38234 zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
38235
38236 if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
38237 ZVAL_COPY_VALUE(&tmp, varname);
38238 zval_copy_ctor(&tmp);
38239 convert_to_string(&tmp);
38240 varname = &tmp;
38241 }
38242
38243 if (IS_VAR != IS_UNUSED) {
38244 zend_class_entry *ce;
38245
38246 if (IS_VAR == IS_CONST) {
38247 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
38248 ce = CACHED_PTR(opline->op2.literal->cache_slot);
38249 } else {
38250 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
38251 if (UNEXPECTED(ce == NULL)) {
38252 CHECK_EXCEPTION();
38253 ZEND_VM_NEXT_OPCODE();
38254 }
38255 CACHE_PTR(opline->op2.literal->cache_slot, ce);
38256 }
38257 } else {
38258 ce = EX_T(opline->op2.var).class_entry;
38259 }
38260 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
38261 if (!value) {
38262 isset = 0;
38263 }
38264 } else {
38265 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
38266 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
38267 isset = 0;
38268 }
38269 }
38270
38271 if (IS_CV != IS_CONST && varname == &tmp) {
38272 zval_dtor(&tmp);
38273 }
38274
38275 }
38276
38277 if (opline->extended_value & ZEND_ISSET) {
38278 if (isset && Z_TYPE_PP(value) != IS_NULL) {
38279 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
38280 } else {
38281 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
38282 }
38283 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
38284 if (!isset || !i_zend_is_true(*value)) {
38285 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
38286 } else {
38287 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
38288 }
38289 }
38290
38291 CHECK_EXCEPTION();
38292 ZEND_VM_NEXT_OPCODE();
38293 }
38294
zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)38295 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
38296 {
38297 USE_OPLINE
38298 zend_free_op free_op2;
38299 zval *container;
38300 zval **value = NULL;
38301 int result = 0;
38302 ulong hval;
38303 zval *offset;
38304
38305 SAVE_OPLINE();
38306 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
38307 offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
38308
38309 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
38310 HashTable *ht;
38311 int isset = 0;
38312
38313 ht = Z_ARRVAL_P(container);
38314
38315 switch (Z_TYPE_P(offset)) {
38316 case IS_DOUBLE:
38317 hval = zend_dval_to_lval(Z_DVAL_P(offset));
38318 goto num_index_prop;
38319 case IS_RESOURCE:
38320 case IS_BOOL:
38321 case IS_LONG:
38322 hval = Z_LVAL_P(offset);
38323 num_index_prop:
38324 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
38325 isset = 1;
38326 }
38327 break;
38328 case IS_STRING:
38329 if (IS_VAR == IS_CONST) {
38330 hval = Z_HASH_P(offset);
38331 } else {
38332 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
38333 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
38334 }
38335 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
38336 isset = 1;
38337 }
38338 break;
38339 case IS_NULL:
38340 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
38341 isset = 1;
38342 }
38343 break;
38344 default:
38345 zend_error(E_WARNING, "Illegal offset type in isset or empty");
38346 break;
38347 }
38348
38349 if (opline->extended_value & ZEND_ISSET) {
38350 if (isset && Z_TYPE_PP(value) == IS_NULL) {
38351 result = 0;
38352 } else {
38353 result = isset;
38354 }
38355 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
38356 if (!isset || !i_zend_is_true(*value)) {
38357 result = 0;
38358 } else {
38359 result = 1;
38360 }
38361 }
38362 zval_ptr_dtor_nogc(&free_op2.var);
38363 } else if (Z_TYPE_P(container) == IS_OBJECT) {
38364 if (0) {
38365 MAKE_REAL_ZVAL_PTR(offset);
38366 }
38367 if (prop_dim) {
38368 if (Z_OBJ_HT_P(container)->has_property) {
38369 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
38370 } else {
38371 zend_error(E_NOTICE, "Trying to check property of non-object");
38372 result = 0;
38373 }
38374 } else {
38375 if (Z_OBJ_HT_P(container)->has_dimension) {
38376 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
38377 } else {
38378 zend_error(E_NOTICE, "Trying to check element of non-array");
38379 result = 0;
38380 }
38381 }
38382 if (0) {
38383 zval_ptr_dtor(&offset);
38384 } else {
38385 zval_ptr_dtor_nogc(&free_op2.var);
38386 }
38387 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
38388 zval tmp;
38389
38390 if (Z_TYPE_P(offset) != IS_LONG) {
38391 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
38392 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
38393 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
38394 ZVAL_COPY_VALUE(&tmp, offset);
38395 zval_copy_ctor(&tmp);
38396 convert_to_long(&tmp);
38397 offset = &tmp;
38398 } else {
38399 /* can not be converted to proper offset, return "not set" */
38400 result = 0;
38401 }
38402 }
38403 if (Z_TYPE_P(offset) == IS_LONG) {
38404 if (opline->extended_value & ZEND_ISSET) {
38405 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
38406 result = 1;
38407 }
38408 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
38409 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
38410 result = 1;
38411 }
38412 }
38413 }
38414 zval_ptr_dtor_nogc(&free_op2.var);
38415 } else {
38416 zval_ptr_dtor_nogc(&free_op2.var);
38417 }
38418
38419 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
38420 if (opline->extended_value & ZEND_ISSET) {
38421 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
38422 } else {
38423 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
38424 }
38425
38426 CHECK_EXCEPTION();
38427 ZEND_VM_NEXT_OPCODE();
38428 }
38429
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38430 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38431 {
38432 return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38433 }
38434
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38435 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38436 {
38437 return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38438 }
38439
ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38440 static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38441 {
38442 USE_OPLINE
38443
38444 /* The generator object is stored in return_value_ptr_ptr */
38445 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
38446
38447 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
38448 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
38449 }
38450
38451 /* Destroy the previously yielded value */
38452 if (generator->value) {
38453 zval_ptr_dtor(&generator->value);
38454 }
38455
38456 /* Destroy the previously yielded key */
38457 if (generator->key) {
38458 zval_ptr_dtor(&generator->key);
38459 }
38460
38461 /* Set the new yielded value */
38462 if (IS_CV != IS_UNUSED) {
38463
38464
38465 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
38466 /* Constants and temporary variables aren't yieldable by reference,
38467 * but we still allow them with a notice. */
38468 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
38469 zval *value, *copy;
38470
38471 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38472
38473 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
38474 ALLOC_ZVAL(copy);
38475 INIT_PZVAL_COPY(copy, value);
38476
38477 /* Temporary variables don't need ctor copying */
38478 if (!0) {
38479 zval_copy_ctor(copy);
38480 }
38481
38482 generator->value = copy;
38483 } else {
38484 zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
38485
38486 if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
38487 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
38488 }
38489
38490 /* If a function call result is yielded and the function did
38491 * not return by reference we throw a notice. */
38492 if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
38493 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
38494 && EX_T(opline->op1.var).var.fcall_returned_reference)
38495 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
38496 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38497
38498 Z_ADDREF_PP(value_ptr);
38499 generator->value = *value_ptr;
38500 } else {
38501 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
38502 Z_ADDREF_PP(value_ptr);
38503 generator->value = *value_ptr;
38504 }
38505
38506 }
38507 } else {
38508 zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
38509
38510 /* Consts, temporary variables and references need copying */
38511 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
38512 || PZVAL_IS_REF(value)
38513 ) {
38514 zval *copy;
38515
38516 ALLOC_ZVAL(copy);
38517 INIT_PZVAL_COPY(copy, value);
38518
38519 /* Temporary variables don't need ctor copying */
38520 if (!0) {
38521 zval_copy_ctor(copy);
38522 }
38523
38524 generator->value = copy;
38525
38526 } else {
38527 if (IS_CV == IS_CV) {
38528 Z_ADDREF_P(value);
38529 }
38530 generator->value = value;
38531 }
38532 }
38533 } else {
38534 /* If no value was specified yield null */
38535 Z_ADDREF(EG(uninitialized_zval));
38536 generator->value = &EG(uninitialized_zval);
38537 }
38538
38539 /* Set the new yielded key */
38540 if (IS_VAR != IS_UNUSED) {
38541 zend_free_op free_op2;
38542 zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
38543
38544 /* Consts, temporary variables and references need copying */
38545 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
38546 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
38547 ) {
38548 zval *copy;
38549
38550 ALLOC_ZVAL(copy);
38551 INIT_PZVAL_COPY(copy, key);
38552
38553 /* Temporary variables don't need ctor copying */
38554 if (!0) {
38555 zval_copy_ctor(copy);
38556 }
38557
38558 generator->key = copy;
38559 } else {
38560 Z_ADDREF_P(key);
38561 generator->key = key;
38562 }
38563
38564 if (Z_TYPE_P(generator->key) == IS_LONG
38565 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
38566 ) {
38567 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
38568 }
38569
38570 zval_ptr_dtor_nogc(&free_op2.var);
38571 } else {
38572 /* If no key was specified we use auto-increment keys */
38573 generator->largest_used_integer_key++;
38574
38575 ALLOC_INIT_ZVAL(generator->key);
38576 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
38577 }
38578
38579 if (RETURN_VALUE_USED(opline)) {
38580 /* If the return value of yield is used set the send
38581 * target and initialize it to NULL */
38582 generator->send_target = &EX_T(opline->result.var).var.ptr;
38583 Z_ADDREF(EG(uninitialized_zval));
38584 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38585 } else {
38586 generator->send_target = NULL;
38587 }
38588
38589 /* We increment to the next op, so we are at the correct position when the
38590 * generator is resumed. */
38591 ZEND_VM_INC_OPCODE();
38592
38593 /* The GOTO VM uses a local opline variable. We need to set the opline
38594 * variable in execute_data so we don't resume at an old position. */
38595 SAVE_OPLINE();
38596
38597 ZEND_VM_RETURN();
38598 }
38599
ZEND_POW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38600 static int ZEND_FASTCALL ZEND_POW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38601 {
38602 USE_OPLINE
38603 zend_free_op free_op2;
38604
38605 SAVE_OPLINE();
38606 pow_function(&EX_T(opline->result.var).tmp_var,
38607 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
38608 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
38609
38610 zval_ptr_dtor_nogc(&free_op2.var);
38611 CHECK_EXCEPTION();
38612 ZEND_VM_NEXT_OPCODE();
38613 }
38614
ZEND_ASSIGN_POW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38615 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38616 {
38617 return zend_binary_assign_op_helper_SPEC_CV_VAR(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38618 }
38619
zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)38620 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
38621 {
38622 USE_OPLINE
38623 zend_free_op free_op_data1;
38624 zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
38625 zval *object;
38626 zval *property = NULL;
38627 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
38628 int have_get_ptr = 0;
38629
38630 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
38631 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
38632 }
38633
38634 make_real_object(object_ptr TSRMLS_CC);
38635 object = *object_ptr;
38636
38637 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38638 zend_error(E_WARNING, "Attempt to assign property of non-object");
38639
38640 FREE_OP(free_op_data1);
38641
38642 if (RETURN_VALUE_USED(opline)) {
38643 PZVAL_LOCK(&EG(uninitialized_zval));
38644 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38645 }
38646 } else {
38647 /* here we are sure we are dealing with an object */
38648 if (0) {
38649 MAKE_REAL_ZVAL_PTR(property);
38650 }
38651
38652 /* here property is a string */
38653 if (opline->extended_value == ZEND_ASSIGN_OBJ
38654 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
38655 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
38656 if (zptr != NULL) { /* NULL means no success in getting PTR */
38657 have_get_ptr = 1;
38658 if (UNEXPECTED(*zptr == &EG(error_zval))) {
38659 if (RETURN_VALUE_USED(opline)) {
38660 PZVAL_LOCK(&EG(uninitialized_zval));
38661 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38662 }
38663 } else {
38664 SEPARATE_ZVAL_IF_NOT_REF(zptr);
38665
38666 binary_op(*zptr, *zptr, value TSRMLS_CC);
38667 if (RETURN_VALUE_USED(opline)) {
38668 PZVAL_LOCK(*zptr);
38669 EX_T(opline->result.var).var.ptr = *zptr;
38670 }
38671 }
38672 }
38673 }
38674
38675 if (!have_get_ptr) {
38676 zval *z = NULL;
38677
38678 Z_ADDREF_P(object);
38679 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
38680 if (Z_OBJ_HT_P(object)->read_property) {
38681 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
38682 }
38683 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
38684 if (Z_OBJ_HT_P(object)->read_dimension) {
38685 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
38686 }
38687 }
38688 if (z) {
38689 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
38690 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
38691
38692 if (Z_REFCOUNT_P(z) == 0) {
38693 GC_REMOVE_ZVAL_FROM_BUFFER(z);
38694 zval_dtor(z);
38695 FREE_ZVAL(z);
38696 }
38697 z = value;
38698 }
38699 Z_ADDREF_P(z);
38700 SEPARATE_ZVAL_IF_NOT_REF(&z);
38701 binary_op(z, z, value TSRMLS_CC);
38702 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
38703 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
38704 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
38705 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
38706 }
38707 if (RETURN_VALUE_USED(opline)) {
38708 PZVAL_LOCK(z);
38709 EX_T(opline->result.var).var.ptr = z;
38710 }
38711 zval_ptr_dtor(&z);
38712 } else {
38713 zend_error(E_WARNING, "Attempt to assign property of non-object");
38714 if (RETURN_VALUE_USED(opline)) {
38715 PZVAL_LOCK(&EG(uninitialized_zval));
38716 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38717 }
38718 }
38719 zval_ptr_dtor(&object);
38720 }
38721
38722 if (0) {
38723 zval_ptr_dtor(&property);
38724 } else {
38725
38726 }
38727 FREE_OP(free_op_data1);
38728 }
38729
38730 /* assign_obj has two opcodes! */
38731 CHECK_EXCEPTION();
38732 ZEND_VM_INC_OPCODE();
38733 ZEND_VM_NEXT_OPCODE();
38734 }
38735
zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)38736 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
38737 {
38738 USE_OPLINE
38739 zend_free_op free_op_data2, free_op_data1;
38740 zval **var_ptr;
38741 zval *value;
38742
38743 SAVE_OPLINE();
38744 switch (opline->extended_value) {
38745 case ZEND_ASSIGN_OBJ:
38746 return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38747 break;
38748 case ZEND_ASSIGN_DIM: {
38749 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
38750
38751 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
38752 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
38753 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
38754 if (IS_CV == IS_VAR && !0) {
38755 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
38756 }
38757 return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38758 } else {
38759 zval *dim = NULL;
38760
38761 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
38762 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
38763 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
38764 }
38765 }
38766 break;
38767 default:
38768 value = NULL;
38769 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
38770 /* do nothing */
38771 break;
38772 }
38773
38774 if (UNEXPECTED(var_ptr == NULL)) {
38775 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
38776 }
38777
38778 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
38779 if (RETURN_VALUE_USED(opline)) {
38780 PZVAL_LOCK(&EG(uninitialized_zval));
38781 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38782 }
38783
38784
38785 CHECK_EXCEPTION();
38786 if (opline->extended_value == ZEND_ASSIGN_DIM) {
38787 ZEND_VM_INC_OPCODE();
38788 }
38789 ZEND_VM_NEXT_OPCODE();
38790 }
38791
38792 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
38793
38794 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
38795 && Z_OBJ_HANDLER_PP(var_ptr, get)
38796 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
38797 /* proxy object */
38798 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
38799 Z_ADDREF_P(objval);
38800 binary_op(objval, objval, value TSRMLS_CC);
38801 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
38802 zval_ptr_dtor(&objval);
38803 } else {
38804 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
38805 }
38806
38807 if (RETURN_VALUE_USED(opline)) {
38808 PZVAL_LOCK(*var_ptr);
38809 EX_T(opline->result.var).var.ptr = *var_ptr;
38810 }
38811
38812 if (opline->extended_value == ZEND_ASSIGN_DIM) {
38813 FREE_OP(free_op_data1);
38814 FREE_OP_VAR_PTR(free_op_data2);
38815
38816 CHECK_EXCEPTION();
38817 ZEND_VM_INC_OPCODE();
38818 } else {
38819
38820 CHECK_EXCEPTION();
38821 }
38822 ZEND_VM_NEXT_OPCODE();
38823 }
38824
ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38825 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38826 {
38827 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38828 }
38829
ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38830 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38831 {
38832 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38833 }
38834
ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38835 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38836 {
38837 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38838 }
38839
ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38840 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38841 {
38842 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38843 }
38844
ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38845 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38846 {
38847 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38848 }
38849
ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38850 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38851 {
38852 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38853 }
38854
ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38855 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38856 {
38857 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38858 }
38859
ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38860 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38861 {
38862 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38863 }
38864
ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38865 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38866 {
38867 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38868 }
38869
ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38870 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38871 {
38872 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38873 }
38874
ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38875 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38876 {
38877 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38878 }
38879
zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type,ZEND_OPCODE_HANDLER_ARGS)38880 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
38881 {
38882 USE_OPLINE
38883 zend_free_op free_op1;
38884 zval *varname;
38885 zval **retval;
38886 zval tmp_varname;
38887 HashTable *target_symbol_table;
38888 ulong hash_value;
38889
38890 SAVE_OPLINE();
38891 varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
38892
38893 if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
38894 ZVAL_COPY_VALUE(&tmp_varname, varname);
38895 zval_copy_ctor(&tmp_varname);
38896 Z_SET_REFCOUNT(tmp_varname, 1);
38897 Z_UNSET_ISREF(tmp_varname);
38898 convert_to_string(&tmp_varname);
38899 varname = &tmp_varname;
38900 }
38901
38902 if (IS_UNUSED != IS_UNUSED) {
38903 zend_class_entry *ce;
38904
38905 if (IS_UNUSED == IS_CONST) {
38906 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
38907 ce = CACHED_PTR(opline->op2.literal->cache_slot);
38908 } else {
38909 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
38910 if (UNEXPECTED(ce == NULL)) {
38911 if (IS_CV != IS_CONST && varname == &tmp_varname) {
38912 zval_dtor(&tmp_varname);
38913 }
38914
38915 CHECK_EXCEPTION();
38916 ZEND_VM_NEXT_OPCODE();
38917 }
38918 CACHE_PTR(opline->op2.literal->cache_slot, ce);
38919 }
38920 } else {
38921 ce = EX_T(opline->op2.var).class_entry;
38922 }
38923 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
38924
38925 } else {
38926 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
38927 /*
38928 if (!target_symbol_table) {
38929 CHECK_EXCEPTION();
38930 ZEND_VM_NEXT_OPCODE();
38931 }
38932 */
38933 if (IS_CV == IS_CONST) {
38934 hash_value = Z_HASH_P(varname);
38935 } else {
38936 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
38937 }
38938
38939 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
38940 switch (type) {
38941 case BP_VAR_R:
38942 case BP_VAR_UNSET:
38943 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
38944 /* break missing intentionally */
38945 case BP_VAR_IS:
38946 retval = &EG(uninitialized_zval_ptr);
38947 break;
38948 case BP_VAR_RW:
38949 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
38950 /* break missing intentionally */
38951 case BP_VAR_W:
38952 Z_ADDREF_P(&EG(uninitialized_zval));
38953 zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
38954 break;
38955 EMPTY_SWITCH_DEFAULT_CASE()
38956 }
38957 }
38958 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
38959 case ZEND_FETCH_GLOBAL:
38960 if (IS_CV != IS_TMP_VAR) {
38961
38962 }
38963 break;
38964 case ZEND_FETCH_LOCAL:
38965
38966 break;
38967 case ZEND_FETCH_STATIC:
38968 zval_update_constant(retval, 1 TSRMLS_CC);
38969 break;
38970 case ZEND_FETCH_GLOBAL_LOCK:
38971 if (IS_CV == IS_VAR && !free_op1.var) {
38972 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
38973 }
38974 break;
38975 }
38976 }
38977
38978
38979 if (IS_CV != IS_CONST && varname == &tmp_varname) {
38980 zval_dtor(&tmp_varname);
38981 }
38982 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
38983 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
38984 }
38985 PZVAL_LOCK(*retval);
38986 switch (type) {
38987 case BP_VAR_R:
38988 case BP_VAR_IS:
38989 EX_T(opline->result.var).var.ptr = *retval;
38990 break;
38991 case BP_VAR_UNSET: {
38992 zend_free_op free_res;
38993
38994 PZVAL_UNLOCK(*retval, &free_res);
38995 if (retval != &EG(uninitialized_zval_ptr)) {
38996 SEPARATE_ZVAL_IF_NOT_REF(retval);
38997 }
38998 PZVAL_LOCK(*retval);
38999 FREE_OP_VAR_PTR(free_res);
39000 }
39001 /* break missing intentionally */
39002 default:
39003 EX_T(opline->result.var).var.ptr_ptr = retval;
39004 break;
39005 }
39006 CHECK_EXCEPTION();
39007 ZEND_VM_NEXT_OPCODE();
39008 }
39009
ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39010 static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39011 {
39012 return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39013 }
39014
ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39015 static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39016 {
39017 return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39018 }
39019
ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39020 static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39021 {
39022 return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39023 }
39024
ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39025 static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39026 {
39027 USE_OPLINE
39028
39029 return zend_fetch_var_address_helper_SPEC_CV_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39030 }
39031
ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39032 static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39033 {
39034 return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39035 }
39036
ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39037 static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39038 {
39039 return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39040 }
39041
ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39042 static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39043 {
39044 USE_OPLINE
39045 zend_free_op free_op1;
39046 zval **container;
39047
39048 SAVE_OPLINE();
39049 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
39050
39051 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
39052 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
39053 }
39054 zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
39055
39056 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
39057 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
39058 }
39059
39060 /* We are going to assign the result by reference */
39061 if (UNEXPECTED(opline->extended_value != 0)) {
39062 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
39063
39064 if (retval_ptr) {
39065 Z_DELREF_PP(retval_ptr);
39066 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
39067 Z_ADDREF_PP(retval_ptr);
39068 }
39069 }
39070
39071 CHECK_EXCEPTION();
39072 ZEND_VM_NEXT_OPCODE();
39073 }
39074
ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39075 static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39076 {
39077 USE_OPLINE
39078 zend_free_op free_op1;
39079 zval **container;
39080
39081 SAVE_OPLINE();
39082 container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
39083
39084 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
39085 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
39086 }
39087 zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
39088
39089 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
39090 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
39091 }
39092
39093 CHECK_EXCEPTION();
39094 ZEND_VM_NEXT_OPCODE();
39095 }
39096
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39097 static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39098 {
39099 USE_OPLINE
39100 zend_free_op free_op1;
39101
39102 SAVE_OPLINE();
39103
39104 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
39105 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
39106 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
39107 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
39108 }
39109 zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
39110 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
39111 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
39112 }
39113
39114
39115 } else {
39116 zval *container;
39117
39118 if (IS_UNUSED == IS_UNUSED) {
39119 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
39120 }
39121 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
39122 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC);
39123
39124
39125 }
39126 CHECK_EXCEPTION();
39127 ZEND_VM_NEXT_OPCODE();
39128 }
39129
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39130 static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39131 {
39132 USE_OPLINE
39133
39134 zval **object_ptr;
39135
39136 SAVE_OPLINE();
39137 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
39138
39139 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
39140 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
39141 }
39142 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
39143
39144 zval *property_name = NULL;
39145
39146 if (0) {
39147 MAKE_REAL_ZVAL_PTR(property_name);
39148 }
39149 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
39150 if (0) {
39151 zval_ptr_dtor(&property_name);
39152 } else {
39153
39154 }
39155 } else {
39156 zend_free_op free_op_data1, free_op_data2;
39157 zval *value;
39158 zval *dim = NULL;
39159 zval **variable_ptr_ptr;
39160
39161 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC);
39162
39163 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
39164 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
39165 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
39166 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
39167 if (RETURN_VALUE_USED(opline)) {
39168 zval *retval;
39169
39170 ALLOC_ZVAL(retval);
39171 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
39172 INIT_PZVAL(retval);
39173 EX_T(opline->result.var).var.ptr = retval;
39174 }
39175 } else if (RETURN_VALUE_USED(opline)) {
39176 PZVAL_LOCK(&EG(uninitialized_zval));
39177 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
39178 }
39179 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
39180 if (IS_TMP_FREE(free_op_data1)) {
39181 zval_dtor(value);
39182 }
39183 if (RETURN_VALUE_USED(opline)) {
39184 PZVAL_LOCK(&EG(uninitialized_zval));
39185 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
39186 }
39187 } else {
39188 if ((opline+1)->op1_type == IS_TMP_VAR) {
39189 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
39190 } else if ((opline+1)->op1_type == IS_CONST) {
39191 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
39192 } else {
39193 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
39194 }
39195 if (RETURN_VALUE_USED(opline)) {
39196 PZVAL_LOCK(value);
39197 EX_T(opline->result.var).var.ptr = value;
39198 }
39199 }
39200 FREE_OP_VAR_PTR(free_op_data2);
39201 FREE_OP_IF_VAR(free_op_data1);
39202 }
39203
39204 /* assign_dim has two opcodes! */
39205 CHECK_EXCEPTION();
39206 ZEND_VM_INC_OPCODE();
39207 ZEND_VM_NEXT_OPCODE();
39208 }
39209
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39210 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39211 {
39212 USE_OPLINE
39213
39214 zval *expr_ptr;
39215
39216 SAVE_OPLINE();
39217 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
39218 zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
39219
39220 if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
39221 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
39222 }
39223 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
39224 expr_ptr = *expr_ptr_ptr;
39225 Z_ADDREF_P(expr_ptr);
39226 } else {
39227 expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
39228 if (0) { /* temporary variable */
39229 zval *new_expr;
39230
39231 ALLOC_ZVAL(new_expr);
39232 INIT_PZVAL_COPY(new_expr, expr_ptr);
39233 expr_ptr = new_expr;
39234 } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
39235 zval *new_expr;
39236
39237 ALLOC_ZVAL(new_expr);
39238 INIT_PZVAL_COPY(new_expr, expr_ptr);
39239 expr_ptr = new_expr;
39240 zendi_zval_copy_ctor(*expr_ptr);
39241
39242 } else if (IS_CV == IS_CV) {
39243 Z_ADDREF_P(expr_ptr);
39244 }
39245 }
39246
39247 if (IS_UNUSED != IS_UNUSED) {
39248
39249 zval *offset = NULL;
39250 ulong hval;
39251
39252 switch (Z_TYPE_P(offset)) {
39253 case IS_DOUBLE:
39254 hval = zend_dval_to_lval(Z_DVAL_P(offset));
39255 goto num_index;
39256 case IS_LONG:
39257 case IS_BOOL:
39258 hval = Z_LVAL_P(offset);
39259 num_index:
39260 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
39261 break;
39262 case IS_STRING:
39263 if (IS_UNUSED == IS_CONST) {
39264 hval = Z_HASH_P(offset);
39265 } else {
39266 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
39267 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
39268 }
39269 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
39270 break;
39271 case IS_NULL:
39272 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
39273 break;
39274 default:
39275 zend_error(E_WARNING, "Illegal offset type");
39276 zval_ptr_dtor(&expr_ptr);
39277 /* do nothing */
39278 break;
39279 }
39280
39281 } else {
39282 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
39283 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
39284 zval_ptr_dtor(&expr_ptr);
39285 }
39286 }
39287 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
39288
39289 }
39290 CHECK_EXCEPTION();
39291 ZEND_VM_NEXT_OPCODE();
39292 }
39293
ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39294 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39295 {
39296 USE_OPLINE
39297
39298 array_init(&EX_T(opline->result.var).tmp_var);
39299 if (IS_CV == IS_UNUSED) {
39300 ZEND_VM_NEXT_OPCODE();
39301 #if 0 || IS_CV != IS_UNUSED
39302 } else {
39303 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39304 #endif
39305 }
39306 }
39307
ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39308 static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39309 {
39310 USE_OPLINE
39311 zval tmp, *varname;
39312 HashTable *target_symbol_table;
39313
39314
39315 SAVE_OPLINE();
39316 if (IS_CV == IS_CV &&
39317 IS_UNUSED == IS_UNUSED &&
39318 (opline->extended_value & ZEND_QUICK_SET)) {
39319 if (EG(active_symbol_table)) {
39320 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
39321
39322 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
39323 EX_CV(opline->op1.var) = NULL;
39324 } else if (EX_CV(opline->op1.var)) {
39325 zval_ptr_dtor(EX_CV(opline->op1.var));
39326 EX_CV(opline->op1.var) = NULL;
39327 }
39328 CHECK_EXCEPTION();
39329 ZEND_VM_NEXT_OPCODE();
39330 }
39331
39332 varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
39333
39334 if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
39335 ZVAL_COPY_VALUE(&tmp, varname);
39336 zval_copy_ctor(&tmp);
39337 convert_to_string(&tmp);
39338 varname = &tmp;
39339 } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
39340 Z_ADDREF_P(varname);
39341 }
39342
39343 if (IS_UNUSED != IS_UNUSED) {
39344 zend_class_entry *ce;
39345
39346 if (IS_UNUSED == IS_CONST) {
39347 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
39348 ce = CACHED_PTR(opline->op2.literal->cache_slot);
39349 } else {
39350 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
39351 if (UNEXPECTED(EG(exception) != NULL)) {
39352 if (IS_CV != IS_CONST && varname == &tmp) {
39353 zval_dtor(&tmp);
39354 } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
39355 zval_ptr_dtor(&varname);
39356 }
39357
39358 HANDLE_EXCEPTION();
39359 }
39360 if (UNEXPECTED(ce == NULL)) {
39361 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
39362 }
39363 CACHE_PTR(opline->op2.literal->cache_slot, ce);
39364 }
39365 } else {
39366 ce = EX_T(opline->op2.var).class_entry;
39367 }
39368 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
39369 } else {
39370 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
39371
39372 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
39373 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
39374 }
39375
39376 if (IS_CV != IS_CONST && varname == &tmp) {
39377 zval_dtor(&tmp);
39378 } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
39379 zval_ptr_dtor(&varname);
39380 }
39381
39382 CHECK_EXCEPTION();
39383 ZEND_VM_NEXT_OPCODE();
39384 }
39385
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39386 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39387 {
39388 USE_OPLINE
39389 zval **value;
39390 zend_bool isset = 1;
39391
39392 SAVE_OPLINE();
39393 if (IS_CV == IS_CV &&
39394 IS_UNUSED == IS_UNUSED &&
39395 (opline->extended_value & ZEND_QUICK_SET)) {
39396 if (EX_CV(opline->op1.var)) {
39397 value = EX_CV(opline->op1.var);
39398 } else if (EG(active_symbol_table)) {
39399 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
39400
39401 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
39402 isset = 0;
39403 }
39404 } else {
39405 isset = 0;
39406 }
39407 } else {
39408 HashTable *target_symbol_table;
39409
39410 zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
39411
39412 if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
39413 ZVAL_COPY_VALUE(&tmp, varname);
39414 zval_copy_ctor(&tmp);
39415 convert_to_string(&tmp);
39416 varname = &tmp;
39417 }
39418
39419 if (IS_UNUSED != IS_UNUSED) {
39420 zend_class_entry *ce;
39421
39422 if (IS_UNUSED == IS_CONST) {
39423 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
39424 ce = CACHED_PTR(opline->op2.literal->cache_slot);
39425 } else {
39426 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
39427 if (UNEXPECTED(ce == NULL)) {
39428 CHECK_EXCEPTION();
39429 ZEND_VM_NEXT_OPCODE();
39430 }
39431 CACHE_PTR(opline->op2.literal->cache_slot, ce);
39432 }
39433 } else {
39434 ce = EX_T(opline->op2.var).class_entry;
39435 }
39436 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
39437 if (!value) {
39438 isset = 0;
39439 }
39440 } else {
39441 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
39442 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
39443 isset = 0;
39444 }
39445 }
39446
39447 if (IS_CV != IS_CONST && varname == &tmp) {
39448 zval_dtor(&tmp);
39449 }
39450
39451 }
39452
39453 if (opline->extended_value & ZEND_ISSET) {
39454 if (isset && Z_TYPE_PP(value) != IS_NULL) {
39455 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
39456 } else {
39457 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
39458 }
39459 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
39460 if (!isset || !i_zend_is_true(*value)) {
39461 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
39462 } else {
39463 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
39464 }
39465 }
39466
39467 CHECK_EXCEPTION();
39468 ZEND_VM_NEXT_OPCODE();
39469 }
39470
ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39471 static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39472 {
39473 USE_OPLINE
39474
39475 /* The generator object is stored in return_value_ptr_ptr */
39476 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
39477
39478 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
39479 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
39480 }
39481
39482 /* Destroy the previously yielded value */
39483 if (generator->value) {
39484 zval_ptr_dtor(&generator->value);
39485 }
39486
39487 /* Destroy the previously yielded key */
39488 if (generator->key) {
39489 zval_ptr_dtor(&generator->key);
39490 }
39491
39492 /* Set the new yielded value */
39493 if (IS_CV != IS_UNUSED) {
39494
39495
39496 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
39497 /* Constants and temporary variables aren't yieldable by reference,
39498 * but we still allow them with a notice. */
39499 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
39500 zval *value, *copy;
39501
39502 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
39503
39504 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
39505 ALLOC_ZVAL(copy);
39506 INIT_PZVAL_COPY(copy, value);
39507
39508 /* Temporary variables don't need ctor copying */
39509 if (!0) {
39510 zval_copy_ctor(copy);
39511 }
39512
39513 generator->value = copy;
39514 } else {
39515 zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
39516
39517 if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
39518 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
39519 }
39520
39521 /* If a function call result is yielded and the function did
39522 * not return by reference we throw a notice. */
39523 if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
39524 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
39525 && EX_T(opline->op1.var).var.fcall_returned_reference)
39526 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
39527 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
39528
39529 Z_ADDREF_PP(value_ptr);
39530 generator->value = *value_ptr;
39531 } else {
39532 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
39533 Z_ADDREF_PP(value_ptr);
39534 generator->value = *value_ptr;
39535 }
39536
39537 }
39538 } else {
39539 zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
39540
39541 /* Consts, temporary variables and references need copying */
39542 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
39543 || PZVAL_IS_REF(value)
39544 ) {
39545 zval *copy;
39546
39547 ALLOC_ZVAL(copy);
39548 INIT_PZVAL_COPY(copy, value);
39549
39550 /* Temporary variables don't need ctor copying */
39551 if (!0) {
39552 zval_copy_ctor(copy);
39553 }
39554
39555 generator->value = copy;
39556
39557 } else {
39558 if (IS_CV == IS_CV) {
39559 Z_ADDREF_P(value);
39560 }
39561 generator->value = value;
39562 }
39563 }
39564 } else {
39565 /* If no value was specified yield null */
39566 Z_ADDREF(EG(uninitialized_zval));
39567 generator->value = &EG(uninitialized_zval);
39568 }
39569
39570 /* Set the new yielded key */
39571 if (IS_UNUSED != IS_UNUSED) {
39572
39573 zval *key = NULL;
39574
39575 /* Consts, temporary variables and references need copying */
39576 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
39577 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
39578 ) {
39579 zval *copy;
39580
39581 ALLOC_ZVAL(copy);
39582 INIT_PZVAL_COPY(copy, key);
39583
39584 /* Temporary variables don't need ctor copying */
39585 if (!0) {
39586 zval_copy_ctor(copy);
39587 }
39588
39589 generator->key = copy;
39590 } else {
39591 Z_ADDREF_P(key);
39592 generator->key = key;
39593 }
39594
39595 if (Z_TYPE_P(generator->key) == IS_LONG
39596 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
39597 ) {
39598 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
39599 }
39600
39601 } else {
39602 /* If no key was specified we use auto-increment keys */
39603 generator->largest_used_integer_key++;
39604
39605 ALLOC_INIT_ZVAL(generator->key);
39606 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
39607 }
39608
39609 if (RETURN_VALUE_USED(opline)) {
39610 /* If the return value of yield is used set the send
39611 * target and initialize it to NULL */
39612 generator->send_target = &EX_T(opline->result.var).var.ptr;
39613 Z_ADDREF(EG(uninitialized_zval));
39614 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
39615 } else {
39616 generator->send_target = NULL;
39617 }
39618
39619 /* We increment to the next op, so we are at the correct position when the
39620 * generator is resumed. */
39621 ZEND_VM_INC_OPCODE();
39622
39623 /* The GOTO VM uses a local opline variable. We need to set the opline
39624 * variable in execute_data so we don't resume at an old position. */
39625 SAVE_OPLINE();
39626
39627 ZEND_VM_RETURN();
39628 }
39629
ZEND_ASSIGN_POW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39630 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39631 {
39632 return zend_binary_assign_op_helper_SPEC_CV_UNUSED(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39633 }
39634
ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39635 static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39636 {
39637 USE_OPLINE
39638
39639
39640 SAVE_OPLINE();
39641 fast_add_function(&EX_T(opline->result.var).tmp_var,
39642 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39643 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39644
39645
39646 CHECK_EXCEPTION();
39647 ZEND_VM_NEXT_OPCODE();
39648 }
39649
ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39650 static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39651 {
39652 USE_OPLINE
39653
39654
39655 SAVE_OPLINE();
39656 fast_sub_function(&EX_T(opline->result.var).tmp_var,
39657 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39658 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39659
39660
39661 CHECK_EXCEPTION();
39662 ZEND_VM_NEXT_OPCODE();
39663 }
39664
ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39665 static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39666 {
39667 USE_OPLINE
39668
39669
39670 SAVE_OPLINE();
39671 fast_mul_function(&EX_T(opline->result.var).tmp_var,
39672 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39673 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39674
39675
39676 CHECK_EXCEPTION();
39677 ZEND_VM_NEXT_OPCODE();
39678 }
39679
ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39680 static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39681 {
39682 USE_OPLINE
39683
39684
39685 SAVE_OPLINE();
39686 fast_div_function(&EX_T(opline->result.var).tmp_var,
39687 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39688 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39689
39690
39691 CHECK_EXCEPTION();
39692 ZEND_VM_NEXT_OPCODE();
39693 }
39694
ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39695 static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39696 {
39697 USE_OPLINE
39698
39699
39700 SAVE_OPLINE();
39701 fast_mod_function(&EX_T(opline->result.var).tmp_var,
39702 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39703 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39704
39705
39706 CHECK_EXCEPTION();
39707 ZEND_VM_NEXT_OPCODE();
39708 }
39709
ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39710 static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39711 {
39712 USE_OPLINE
39713
39714
39715 SAVE_OPLINE();
39716 shift_left_function(&EX_T(opline->result.var).tmp_var,
39717 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39718 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39719
39720
39721 CHECK_EXCEPTION();
39722 ZEND_VM_NEXT_OPCODE();
39723 }
39724
ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39725 static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39726 {
39727 USE_OPLINE
39728
39729
39730 SAVE_OPLINE();
39731 shift_right_function(&EX_T(opline->result.var).tmp_var,
39732 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39733 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39734
39735
39736 CHECK_EXCEPTION();
39737 ZEND_VM_NEXT_OPCODE();
39738 }
39739
ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39740 static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39741 {
39742 USE_OPLINE
39743
39744
39745 SAVE_OPLINE();
39746 concat_function(&EX_T(opline->result.var).tmp_var,
39747 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39748 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39749
39750
39751 CHECK_EXCEPTION();
39752 ZEND_VM_NEXT_OPCODE();
39753 }
39754
ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39755 static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39756 {
39757 USE_OPLINE
39758
39759
39760 SAVE_OPLINE();
39761 is_identical_function(&EX_T(opline->result.var).tmp_var,
39762 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39763 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39764
39765
39766 CHECK_EXCEPTION();
39767 ZEND_VM_NEXT_OPCODE();
39768 }
39769
ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39770 static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39771 {
39772 USE_OPLINE
39773
39774 zval *result = &EX_T(opline->result.var).tmp_var;
39775
39776 SAVE_OPLINE();
39777 is_identical_function(result,
39778 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39779 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39780 Z_LVAL_P(result) = !Z_LVAL_P(result);
39781
39782
39783 CHECK_EXCEPTION();
39784 ZEND_VM_NEXT_OPCODE();
39785 }
39786
ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39787 static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39788 {
39789 USE_OPLINE
39790
39791 zval *result = &EX_T(opline->result.var).tmp_var;
39792
39793 SAVE_OPLINE();
39794 ZVAL_BOOL(result, fast_equal_function(result,
39795 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39796 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
39797
39798
39799 CHECK_EXCEPTION();
39800 ZEND_VM_NEXT_OPCODE();
39801 }
39802
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39803 static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39804 {
39805 USE_OPLINE
39806
39807 zval *result = &EX_T(opline->result.var).tmp_var;
39808
39809 SAVE_OPLINE();
39810 ZVAL_BOOL(result, fast_not_equal_function(result,
39811 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39812 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
39813
39814
39815 CHECK_EXCEPTION();
39816 ZEND_VM_NEXT_OPCODE();
39817 }
39818
ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39819 static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39820 {
39821 USE_OPLINE
39822
39823 zval *result = &EX_T(opline->result.var).tmp_var;
39824
39825 SAVE_OPLINE();
39826 ZVAL_BOOL(result, fast_is_smaller_function(result,
39827 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39828 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
39829
39830
39831 CHECK_EXCEPTION();
39832 ZEND_VM_NEXT_OPCODE();
39833 }
39834
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39835 static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39836 {
39837 USE_OPLINE
39838
39839 zval *result = &EX_T(opline->result.var).tmp_var;
39840
39841 SAVE_OPLINE();
39842 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
39843 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39844 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
39845
39846
39847 CHECK_EXCEPTION();
39848 ZEND_VM_NEXT_OPCODE();
39849 }
39850
ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39851 static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39852 {
39853 USE_OPLINE
39854
39855
39856 SAVE_OPLINE();
39857 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
39858 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39859 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39860
39861
39862 CHECK_EXCEPTION();
39863 ZEND_VM_NEXT_OPCODE();
39864 }
39865
ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39866 static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39867 {
39868 USE_OPLINE
39869
39870
39871 SAVE_OPLINE();
39872 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
39873 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39874 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39875
39876
39877 CHECK_EXCEPTION();
39878 ZEND_VM_NEXT_OPCODE();
39879 }
39880
ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39881 static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39882 {
39883 USE_OPLINE
39884
39885
39886 SAVE_OPLINE();
39887 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
39888 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39889 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39890
39891
39892 CHECK_EXCEPTION();
39893 ZEND_VM_NEXT_OPCODE();
39894 }
39895
ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39896 static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39897 {
39898 USE_OPLINE
39899
39900
39901 SAVE_OPLINE();
39902 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
39903 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39904 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39905
39906
39907 CHECK_EXCEPTION();
39908 ZEND_VM_NEXT_OPCODE();
39909 }
39910
zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)39911 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
39912 {
39913 USE_OPLINE
39914 zend_free_op free_op_data1;
39915 zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
39916 zval *object;
39917 zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
39918 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
39919 int have_get_ptr = 0;
39920
39921 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
39922 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
39923 }
39924
39925 make_real_object(object_ptr TSRMLS_CC);
39926 object = *object_ptr;
39927
39928 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39929 zend_error(E_WARNING, "Attempt to assign property of non-object");
39930
39931 FREE_OP(free_op_data1);
39932
39933 if (RETURN_VALUE_USED(opline)) {
39934 PZVAL_LOCK(&EG(uninitialized_zval));
39935 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
39936 }
39937 } else {
39938 /* here we are sure we are dealing with an object */
39939 if (0) {
39940 MAKE_REAL_ZVAL_PTR(property);
39941 }
39942
39943 /* here property is a string */
39944 if (opline->extended_value == ZEND_ASSIGN_OBJ
39945 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
39946 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
39947 if (zptr != NULL) { /* NULL means no success in getting PTR */
39948 have_get_ptr = 1;
39949 if (UNEXPECTED(*zptr == &EG(error_zval))) {
39950 if (RETURN_VALUE_USED(opline)) {
39951 PZVAL_LOCK(&EG(uninitialized_zval));
39952 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
39953 }
39954 } else {
39955 SEPARATE_ZVAL_IF_NOT_REF(zptr);
39956
39957 binary_op(*zptr, *zptr, value TSRMLS_CC);
39958 if (RETURN_VALUE_USED(opline)) {
39959 PZVAL_LOCK(*zptr);
39960 EX_T(opline->result.var).var.ptr = *zptr;
39961 }
39962 }
39963 }
39964 }
39965
39966 if (!have_get_ptr) {
39967 zval *z = NULL;
39968
39969 Z_ADDREF_P(object);
39970 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
39971 if (Z_OBJ_HT_P(object)->read_property) {
39972 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
39973 }
39974 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
39975 if (Z_OBJ_HT_P(object)->read_dimension) {
39976 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
39977 }
39978 }
39979 if (z) {
39980 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
39981 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
39982
39983 if (Z_REFCOUNT_P(z) == 0) {
39984 GC_REMOVE_ZVAL_FROM_BUFFER(z);
39985 zval_dtor(z);
39986 FREE_ZVAL(z);
39987 }
39988 z = value;
39989 }
39990 Z_ADDREF_P(z);
39991 SEPARATE_ZVAL_IF_NOT_REF(&z);
39992 binary_op(z, z, value TSRMLS_CC);
39993 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
39994 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
39995 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
39996 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
39997 }
39998 if (RETURN_VALUE_USED(opline)) {
39999 PZVAL_LOCK(z);
40000 EX_T(opline->result.var).var.ptr = z;
40001 }
40002 zval_ptr_dtor(&z);
40003 } else {
40004 zend_error(E_WARNING, "Attempt to assign property of non-object");
40005 if (RETURN_VALUE_USED(opline)) {
40006 PZVAL_LOCK(&EG(uninitialized_zval));
40007 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40008 }
40009 }
40010 zval_ptr_dtor(&object);
40011 }
40012
40013 if (0) {
40014 zval_ptr_dtor(&property);
40015 } else {
40016
40017 }
40018 FREE_OP(free_op_data1);
40019 }
40020
40021 /* assign_obj has two opcodes! */
40022 CHECK_EXCEPTION();
40023 ZEND_VM_INC_OPCODE();
40024 ZEND_VM_NEXT_OPCODE();
40025 }
40026
zend_binary_assign_op_helper_SPEC_CV_CV(int (* binary_op)(zval * result,zval * op1,zval * op2 TSRMLS_DC),ZEND_OPCODE_HANDLER_ARGS)40027 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
40028 {
40029 USE_OPLINE
40030 zend_free_op free_op_data2, free_op_data1;
40031 zval **var_ptr;
40032 zval *value;
40033
40034 SAVE_OPLINE();
40035 switch (opline->extended_value) {
40036 case ZEND_ASSIGN_OBJ:
40037 return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40038 break;
40039 case ZEND_ASSIGN_DIM: {
40040 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
40041
40042 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40043 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40044 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
40045 if (IS_CV == IS_VAR && !0) {
40046 Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
40047 }
40048 return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40049 } else {
40050 zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40051
40052 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC);
40053 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
40054 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
40055 }
40056 }
40057 break;
40058 default:
40059 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40060 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
40061 /* do nothing */
40062 break;
40063 }
40064
40065 if (UNEXPECTED(var_ptr == NULL)) {
40066 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
40067 }
40068
40069 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
40070 if (RETURN_VALUE_USED(opline)) {
40071 PZVAL_LOCK(&EG(uninitialized_zval));
40072 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40073 }
40074
40075
40076 CHECK_EXCEPTION();
40077 if (opline->extended_value == ZEND_ASSIGN_DIM) {
40078 ZEND_VM_INC_OPCODE();
40079 }
40080 ZEND_VM_NEXT_OPCODE();
40081 }
40082
40083 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
40084
40085 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
40086 && Z_OBJ_HANDLER_PP(var_ptr, get)
40087 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
40088 /* proxy object */
40089 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
40090 Z_ADDREF_P(objval);
40091 binary_op(objval, objval, value TSRMLS_CC);
40092 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
40093 zval_ptr_dtor(&objval);
40094 } else {
40095 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
40096 }
40097
40098 if (RETURN_VALUE_USED(opline)) {
40099 PZVAL_LOCK(*var_ptr);
40100 EX_T(opline->result.var).var.ptr = *var_ptr;
40101 }
40102
40103 if (opline->extended_value == ZEND_ASSIGN_DIM) {
40104 FREE_OP(free_op_data1);
40105 FREE_OP_VAR_PTR(free_op_data2);
40106
40107 CHECK_EXCEPTION();
40108 ZEND_VM_INC_OPCODE();
40109 } else {
40110
40111 CHECK_EXCEPTION();
40112 }
40113 ZEND_VM_NEXT_OPCODE();
40114 }
40115
ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40116 static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40117 {
40118 return zend_binary_assign_op_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40119 }
40120
ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40121 static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40122 {
40123 return zend_binary_assign_op_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40124 }
40125
ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40126 static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40127 {
40128 return zend_binary_assign_op_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40129 }
40130
ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40131 static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40132 {
40133 return zend_binary_assign_op_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40134 }
40135
ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40136 static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40137 {
40138 return zend_binary_assign_op_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40139 }
40140
ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40141 static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40142 {
40143 return zend_binary_assign_op_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40144 }
40145
ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40146 static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40147 {
40148 return zend_binary_assign_op_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40149 }
40150
ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40151 static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40152 {
40153 return zend_binary_assign_op_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40154 }
40155
ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40156 static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40157 {
40158 return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40159 }
40160
ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40161 static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40162 {
40163 return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40164 }
40165
ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40166 static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40167 {
40168 return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40169 }
40170
zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)40171 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
40172 {
40173 USE_OPLINE
40174
40175 zval **object_ptr;
40176 zval *object;
40177 zval *property;
40178 zval **retval;
40179 int have_get_ptr = 0;
40180
40181 SAVE_OPLINE();
40182 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
40183 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40184 retval = &EX_T(opline->result.var).var.ptr;
40185
40186 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
40187 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
40188 }
40189
40190 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
40191 object = *object_ptr;
40192
40193 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
40194 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
40195
40196 if (RETURN_VALUE_USED(opline)) {
40197 PZVAL_LOCK(&EG(uninitialized_zval));
40198 *retval = &EG(uninitialized_zval);
40199 }
40200
40201 CHECK_EXCEPTION();
40202 ZEND_VM_NEXT_OPCODE();
40203 }
40204
40205 /* here we are sure we are dealing with an object */
40206
40207 if (0) {
40208 MAKE_REAL_ZVAL_PTR(property);
40209 }
40210
40211 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
40212 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40213 if (zptr != NULL) { /* NULL means no success in getting PTR */
40214 have_get_ptr = 1;
40215 if (UNEXPECTED(*zptr == &EG(error_zval))) {
40216 if (RETURN_VALUE_USED(opline)) {
40217 PZVAL_LOCK(&EG(uninitialized_zval));
40218 *retval = &EG(uninitialized_zval);
40219 }
40220 } else {
40221 SEPARATE_ZVAL_IF_NOT_REF(zptr);
40222
40223 incdec_op(*zptr);
40224 if (RETURN_VALUE_USED(opline)) {
40225 *retval = *zptr;
40226 PZVAL_LOCK(*retval);
40227 }
40228 }
40229 }
40230 }
40231
40232 if (!have_get_ptr) {
40233 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
40234 zval *z;
40235
40236 Z_ADDREF_P(object);
40237 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40238
40239 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
40240 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
40241
40242 if (Z_REFCOUNT_P(z) == 0) {
40243 GC_REMOVE_ZVAL_FROM_BUFFER(z);
40244 zval_dtor(z);
40245 FREE_ZVAL(z);
40246 }
40247 z = value;
40248 }
40249 Z_ADDREF_P(z);
40250 SEPARATE_ZVAL_IF_NOT_REF(&z);
40251 incdec_op(z);
40252 *retval = z;
40253 Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40254 zval_ptr_dtor(&object);
40255 SELECTIVE_PZVAL_LOCK(*retval, opline);
40256 zval_ptr_dtor(&z);
40257 } else {
40258 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
40259 if (RETURN_VALUE_USED(opline)) {
40260 PZVAL_LOCK(&EG(uninitialized_zval));
40261 *retval = &EG(uninitialized_zval);
40262 }
40263 }
40264 }
40265
40266 if (0) {
40267 zval_ptr_dtor(&property);
40268 } else {
40269
40270 }
40271
40272 CHECK_EXCEPTION();
40273 ZEND_VM_NEXT_OPCODE();
40274 }
40275
ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40276 static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40277 {
40278 return zend_pre_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40279 }
40280
ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40281 static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40282 {
40283 return zend_pre_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40284 }
40285
zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op,ZEND_OPCODE_HANDLER_ARGS)40286 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
40287 {
40288 USE_OPLINE
40289
40290 zval **object_ptr;
40291 zval *object;
40292 zval *property;
40293 zval *retval;
40294 int have_get_ptr = 0;
40295
40296 SAVE_OPLINE();
40297 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
40298 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40299 retval = &EX_T(opline->result.var).tmp_var;
40300
40301 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
40302 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
40303 }
40304
40305 make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
40306 object = *object_ptr;
40307
40308 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
40309 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
40310
40311 ZVAL_NULL(retval);
40312
40313 CHECK_EXCEPTION();
40314 ZEND_VM_NEXT_OPCODE();
40315 }
40316
40317 /* here we are sure we are dealing with an object */
40318
40319 if (0) {
40320 MAKE_REAL_ZVAL_PTR(property);
40321 }
40322
40323 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
40324 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40325 if (zptr != NULL) { /* NULL means no success in getting PTR */
40326 have_get_ptr = 1;
40327 if (UNEXPECTED(*zptr == &EG(error_zval))) {
40328 ZVAL_NULL(retval);
40329 } else {
40330 SEPARATE_ZVAL_IF_NOT_REF(zptr);
40331
40332 ZVAL_COPY_VALUE(retval, *zptr);
40333 zendi_zval_copy_ctor(*retval);
40334
40335 incdec_op(*zptr);
40336 }
40337 }
40338 }
40339
40340 if (!have_get_ptr) {
40341 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
40342 zval *z, *z_copy;
40343
40344 Z_ADDREF_P(object);
40345 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40346 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
40347 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
40348
40349 if (Z_REFCOUNT_P(z) == 0) {
40350 GC_REMOVE_ZVAL_FROM_BUFFER(z);
40351 zval_dtor(z);
40352 FREE_ZVAL(z);
40353 }
40354 z = value;
40355 }
40356 ZVAL_COPY_VALUE(retval, z);
40357 zendi_zval_copy_ctor(*retval);
40358 ALLOC_ZVAL(z_copy);
40359 INIT_PZVAL_COPY(z_copy, z);
40360 zendi_zval_copy_ctor(*z_copy);
40361 incdec_op(z_copy);
40362 Z_ADDREF_P(z);
40363 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40364 zval_ptr_dtor(&object);
40365 zval_ptr_dtor(&z_copy);
40366 zval_ptr_dtor(&z);
40367 } else {
40368 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
40369 ZVAL_NULL(retval);
40370 }
40371 }
40372
40373 if (0) {
40374 zval_ptr_dtor(&property);
40375 } else {
40376
40377 }
40378
40379 CHECK_EXCEPTION();
40380 ZEND_VM_NEXT_OPCODE();
40381 }
40382
ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40383 static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40384 {
40385 return zend_post_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40386 }
40387
ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40388 static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40389 {
40390 return zend_post_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40391 }
40392
ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40393 static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40394 {
40395 USE_OPLINE
40396
40397 zval *container;
40398
40399 SAVE_OPLINE();
40400 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
40401 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
40402
40403 if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
40404
40405 }
40406 CHECK_EXCEPTION();
40407 ZEND_VM_NEXT_OPCODE();
40408 }
40409
ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40410 static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40411 {
40412 USE_OPLINE
40413 zend_free_op free_op1;
40414 zval **container;
40415
40416 SAVE_OPLINE();
40417 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40418
40419 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40420 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40421 }
40422 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
40423
40424 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40425 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40426 }
40427
40428 /* We are going to assign the result by reference */
40429 if (UNEXPECTED(opline->extended_value != 0)) {
40430 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
40431
40432 if (retval_ptr) {
40433 Z_DELREF_PP(retval_ptr);
40434 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
40435 Z_ADDREF_PP(retval_ptr);
40436 }
40437 }
40438
40439 CHECK_EXCEPTION();
40440 ZEND_VM_NEXT_OPCODE();
40441 }
40442
ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40443 static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40444 {
40445 USE_OPLINE
40446 zend_free_op free_op1;
40447 zval **container;
40448
40449 SAVE_OPLINE();
40450 container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
40451
40452 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40453 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40454 }
40455 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC);
40456
40457 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40458 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40459 }
40460
40461 CHECK_EXCEPTION();
40462 ZEND_VM_NEXT_OPCODE();
40463 }
40464
ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40465 static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40466 {
40467 USE_OPLINE
40468
40469 zval *container;
40470
40471 SAVE_OPLINE();
40472 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
40473 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC);
40474
40475
40476 CHECK_EXCEPTION();
40477 ZEND_VM_NEXT_OPCODE();
40478 }
40479
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40480 static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40481 {
40482 USE_OPLINE
40483 zend_free_op free_op1;
40484
40485 SAVE_OPLINE();
40486
40487 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
40488 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40489 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40490 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40491 }
40492 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
40493 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40494 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40495 }
40496
40497
40498 } else {
40499 zval *container;
40500
40501 if (IS_CV == IS_UNUSED) {
40502 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
40503 }
40504 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
40505 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
40506
40507
40508 }
40509 CHECK_EXCEPTION();
40510 ZEND_VM_NEXT_OPCODE();
40511 }
40512
ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40513 static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40514 {
40515 USE_OPLINE
40516 zend_free_op free_op1;
40517 zval **container;
40518
40519 SAVE_OPLINE();
40520 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
40521
40522 if (IS_CV == IS_CV) {
40523 if (container != &EG(uninitialized_zval_ptr)) {
40524 SEPARATE_ZVAL_IF_NOT_REF(container);
40525 }
40526 }
40527 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40528 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40529 }
40530 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_UNSET TSRMLS_CC);
40531
40532 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40533 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40534 }
40535
40536 if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
40537 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
40538 ZEND_VM_NEXT_OPCODE();
40539 } else {
40540 zend_free_op free_res;
40541 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
40542
40543 PZVAL_UNLOCK(*retval_ptr, &free_res);
40544 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
40545 SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
40546 }
40547 PZVAL_LOCK(*retval_ptr);
40548 FREE_OP_VAR_PTR(free_res);
40549 CHECK_EXCEPTION();
40550 ZEND_VM_NEXT_OPCODE();
40551 }
40552 }
40553
zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS)40554 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS)
40555 {
40556 USE_OPLINE
40557
40558 zval *container;
40559
40560 zval *offset;
40561
40562 SAVE_OPLINE();
40563 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
40564 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40565
40566 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
40567 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
40568 zend_error(E_NOTICE, "Trying to get property of non-object");
40569 PZVAL_LOCK(&EG(uninitialized_zval));
40570 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40571
40572 } else {
40573 zval *retval;
40574
40575 if (0) {
40576 MAKE_REAL_ZVAL_PTR(offset);
40577 }
40578
40579 /* here we are sure we are dealing with an object */
40580 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40581
40582 PZVAL_LOCK(retval);
40583 EX_T(opline->result.var).var.ptr = retval;
40584
40585 if (0) {
40586 zval_ptr_dtor(&offset);
40587 } else {
40588
40589 }
40590 }
40591
40592 CHECK_EXCEPTION();
40593 ZEND_VM_NEXT_OPCODE();
40594 }
40595
ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40596 static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40597 {
40598 return zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40599 }
40600
ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40601 static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40602 {
40603 USE_OPLINE
40604 zend_free_op free_op1;
40605 zval *property;
40606 zval **container;
40607
40608 SAVE_OPLINE();
40609 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40610
40611 if (0) {
40612 MAKE_REAL_ZVAL_PTR(property);
40613 }
40614 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40615 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40616 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
40617 }
40618
40619 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
40620 if (0) {
40621 zval_ptr_dtor(&property);
40622 } else {
40623
40624 }
40625 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40626 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40627 }
40628
40629 /* We are going to assign the result by reference */
40630 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
40631 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
40632
40633 Z_DELREF_PP(retval_ptr);
40634 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
40635 Z_ADDREF_PP(retval_ptr);
40636 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
40637 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
40638 }
40639
40640 CHECK_EXCEPTION();
40641 ZEND_VM_NEXT_OPCODE();
40642 }
40643
ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40644 static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40645 {
40646 USE_OPLINE
40647 zend_free_op free_op1;
40648 zval *property;
40649 zval **container;
40650
40651 SAVE_OPLINE();
40652 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40653 container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
40654
40655 if (0) {
40656 MAKE_REAL_ZVAL_PTR(property);
40657 }
40658 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40659 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
40660 }
40661 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
40662 if (0) {
40663 zval_ptr_dtor(&property);
40664 } else {
40665
40666 }
40667 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40668 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40669 }
40670
40671 CHECK_EXCEPTION();
40672 ZEND_VM_NEXT_OPCODE();
40673 }
40674
ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40675 static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40676 {
40677 USE_OPLINE
40678
40679 zval *container;
40680
40681 zval *offset;
40682
40683 SAVE_OPLINE();
40684 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
40685 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40686
40687 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
40688 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
40689 PZVAL_LOCK(&EG(uninitialized_zval));
40690 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40691
40692 } else {
40693 zval *retval;
40694
40695 if (0) {
40696 MAKE_REAL_ZVAL_PTR(offset);
40697 }
40698
40699 /* here we are sure we are dealing with an object */
40700 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40701
40702 PZVAL_LOCK(retval);
40703 EX_T(opline->result.var).var.ptr = retval;
40704
40705 if (0) {
40706 zval_ptr_dtor(&offset);
40707 } else {
40708
40709 }
40710 }
40711
40712 CHECK_EXCEPTION();
40713 ZEND_VM_NEXT_OPCODE();
40714 }
40715
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40716 static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40717 {
40718 USE_OPLINE
40719
40720 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
40721 /* Behave like FETCH_OBJ_W */
40722 zend_free_op free_op1;
40723 zval *property;
40724 zval **container;
40725
40726 SAVE_OPLINE();
40727 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40728 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40729
40730 if (0) {
40731 MAKE_REAL_ZVAL_PTR(property);
40732 }
40733 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40734 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
40735 }
40736 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
40737 if (0) {
40738 zval_ptr_dtor(&property);
40739 } else {
40740
40741 }
40742 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40743 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40744 }
40745
40746 CHECK_EXCEPTION();
40747 ZEND_VM_NEXT_OPCODE();
40748 } else {
40749 return zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40750 }
40751 }
40752
ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40753 static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40754 {
40755 USE_OPLINE
40756 zend_free_op free_op1, free_res;
40757 zval **container;
40758 zval *property;
40759
40760 SAVE_OPLINE();
40761 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
40762 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40763
40764 if (IS_CV == IS_CV) {
40765 if (container != &EG(uninitialized_zval_ptr)) {
40766 SEPARATE_ZVAL_IF_NOT_REF(container);
40767 }
40768 }
40769 if (0) {
40770 MAKE_REAL_ZVAL_PTR(property);
40771 }
40772 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40773 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
40774 }
40775 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
40776 if (0) {
40777 zval_ptr_dtor(&property);
40778 } else {
40779
40780 }
40781 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40782 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40783 }
40784
40785 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
40786 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
40787 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
40788 }
40789 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
40790 FREE_OP_VAR_PTR(free_res);
40791 CHECK_EXCEPTION();
40792 ZEND_VM_NEXT_OPCODE();
40793 }
40794
ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40795 static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40796 {
40797 USE_OPLINE
40798
40799 zval **object_ptr;
40800 zval *property_name;
40801
40802 SAVE_OPLINE();
40803 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40804 property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40805
40806 if (0) {
40807 MAKE_REAL_ZVAL_PTR(property_name);
40808 }
40809 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
40810 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40811 }
40812 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40813 if (0) {
40814 zval_ptr_dtor(&property_name);
40815 } else {
40816
40817 }
40818
40819 /* assign_obj has two opcodes! */
40820 CHECK_EXCEPTION();
40821 ZEND_VM_INC_OPCODE();
40822 ZEND_VM_NEXT_OPCODE();
40823 }
40824
ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40825 static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40826 {
40827 USE_OPLINE
40828
40829 zval **object_ptr;
40830
40831 SAVE_OPLINE();
40832 object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40833
40834 if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
40835 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40836 }
40837 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
40838
40839 zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40840
40841 if (0) {
40842 MAKE_REAL_ZVAL_PTR(property_name);
40843 }
40844 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40845 if (0) {
40846 zval_ptr_dtor(&property_name);
40847 } else {
40848
40849 }
40850 } else {
40851 zend_free_op free_op_data1, free_op_data2;
40852 zval *value;
40853 zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40854 zval **variable_ptr_ptr;
40855
40856 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W TSRMLS_CC);
40857
40858 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
40859 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
40860 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
40861 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
40862 if (RETURN_VALUE_USED(opline)) {
40863 zval *retval;
40864
40865 ALLOC_ZVAL(retval);
40866 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
40867 INIT_PZVAL(retval);
40868 EX_T(opline->result.var).var.ptr = retval;
40869 }
40870 } else if (RETURN_VALUE_USED(opline)) {
40871 PZVAL_LOCK(&EG(uninitialized_zval));
40872 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40873 }
40874 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
40875 if (IS_TMP_FREE(free_op_data1)) {
40876 zval_dtor(value);
40877 }
40878 if (RETURN_VALUE_USED(opline)) {
40879 PZVAL_LOCK(&EG(uninitialized_zval));
40880 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40881 }
40882 } else {
40883 if ((opline+1)->op1_type == IS_TMP_VAR) {
40884 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40885 } else if ((opline+1)->op1_type == IS_CONST) {
40886 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40887 } else {
40888 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40889 }
40890 if (RETURN_VALUE_USED(opline)) {
40891 PZVAL_LOCK(value);
40892 EX_T(opline->result.var).var.ptr = value;
40893 }
40894 }
40895 FREE_OP_VAR_PTR(free_op_data2);
40896 FREE_OP_IF_VAR(free_op_data1);
40897 }
40898
40899 /* assign_dim has two opcodes! */
40900 CHECK_EXCEPTION();
40901 ZEND_VM_INC_OPCODE();
40902 ZEND_VM_NEXT_OPCODE();
40903 }
40904
ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40905 static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40906 {
40907 USE_OPLINE
40908
40909 zval *value;
40910 zval **variable_ptr_ptr;
40911
40912 SAVE_OPLINE();
40913 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40914 variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40915
40916 if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
40917 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) {
40918 if (RETURN_VALUE_USED(opline)) {
40919 zval *retval;
40920
40921 ALLOC_ZVAL(retval);
40922 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
40923 INIT_PZVAL(retval);
40924 EX_T(opline->result.var).var.ptr = retval;
40925 }
40926 } else if (RETURN_VALUE_USED(opline)) {
40927 PZVAL_LOCK(&EG(uninitialized_zval));
40928 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40929 }
40930 } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
40931 if (0) {
40932 zval_dtor(value);
40933 }
40934 if (RETURN_VALUE_USED(opline)) {
40935 PZVAL_LOCK(&EG(uninitialized_zval));
40936 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40937 }
40938 } else {
40939 if (IS_CV == IS_TMP_VAR) {
40940 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40941 } else if (IS_CV == IS_CONST) {
40942 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40943 } else {
40944 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40945 }
40946 if (RETURN_VALUE_USED(opline)) {
40947 PZVAL_LOCK(value);
40948 EX_T(opline->result.var).var.ptr = value;
40949 }
40950 }
40951
40952 if (IS_CV == IS_VAR && 0) {
40953 zval_ptr_dtor_nogc(&value);
40954 }
40955
40956 /* zend_assign_to_variable() always takes care of op2, never free it! */
40957
40958 CHECK_EXCEPTION();
40959 ZEND_VM_NEXT_OPCODE();
40960 }
40961
ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40962 static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40963 {
40964 USE_OPLINE
40965 zend_free_op free_op2;
40966 zval **variable_ptr_ptr;
40967 zval **value_ptr_ptr;
40968
40969 SAVE_OPLINE();
40970 value_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC);
40971
40972 if (IS_CV == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
40973 zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
40974 }
40975
40976 if (IS_CV == IS_VAR &&
40977 value_ptr_ptr &&
40978 !Z_ISREF_PP(value_ptr_ptr) &&
40979 opline->extended_value == ZEND_RETURNS_FUNCTION &&
40980 !EX_T(opline->op2.var).var.fcall_returned_reference) {
40981 if (free_op2.var == NULL) {
40982 PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
40983 }
40984 zend_error(E_STRICT, "Only variables should be assigned by reference");
40985 if (UNEXPECTED(EG(exception) != NULL)) {
40986
40987 HANDLE_EXCEPTION();
40988 }
40989 return ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40990 } else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
40991 PZVAL_LOCK(*value_ptr_ptr);
40992 }
40993
40994 variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40995 if ((IS_CV == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
40996 (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
40997 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
40998 } else if ((IS_CV == IS_VAR && UNEXPECTED(*value_ptr_ptr == &EG(error_zval))) ||
40999 (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval)))) {
41000 variable_ptr_ptr = &EG(uninitialized_zval_ptr);
41001 } else {
41002 zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
41003 if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
41004 Z_DELREF_PP(variable_ptr_ptr);
41005 }
41006 }
41007
41008 if (RETURN_VALUE_USED(opline)) {
41009 PZVAL_LOCK(*variable_ptr_ptr);
41010 EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
41011 }
41012
41013
41014 CHECK_EXCEPTION();
41015 ZEND_VM_NEXT_OPCODE();
41016 }
41017
ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41018 static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41019 {
41020 USE_OPLINE
41021 zval *function_name;
41022 char *function_name_strval;
41023 int function_name_strlen;
41024
41025 call_slot *call = EX(call_slots) + opline->result.num;
41026
41027 SAVE_OPLINE();
41028
41029 function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
41030
41031 if (IS_CV != IS_CONST &&
41032 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
41033 if (UNEXPECTED(EG(exception) != NULL)) {
41034 HANDLE_EXCEPTION();
41035 }
41036 zend_error_noreturn(E_ERROR, "Method name must be a string");
41037 }
41038
41039 function_name_strval = Z_STRVAL_P(function_name);
41040 function_name_strlen = Z_STRLEN_P(function_name);
41041
41042 call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
41043
41044 if (EXPECTED(call->object != NULL) &&
41045 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
41046 call->called_scope = Z_OBJCE_P(call->object);
41047
41048 if (IS_CV != IS_CONST ||
41049 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
41050 zval *object = call->object;
41051
41052 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
41053 zend_error_noreturn(E_ERROR, "Object does not support method calls");
41054 }
41055
41056 /* First, locate the function. */
41057 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
41058 if (UNEXPECTED(call->fbc == NULL)) {
41059 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
41060 }
41061 if (IS_CV == IS_CONST &&
41062 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
41063 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
41064 EXPECTED(call->object == object)) {
41065 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
41066 }
41067 }
41068 } else {
41069 if (UNEXPECTED(EG(exception) != NULL)) {
41070
41071 HANDLE_EXCEPTION();
41072 }
41073 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
41074 }
41075
41076 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
41077 call->object = NULL;
41078 } else {
41079 if (!PZVAL_IS_REF(call->object)) {
41080 Z_ADDREF_P(call->object); /* For $this pointer */
41081 } else {
41082 zval *this_ptr;
41083 ALLOC_ZVAL(this_ptr);
41084 INIT_PZVAL_COPY(this_ptr, call->object);
41085 zval_copy_ctor(this_ptr);
41086 call->object = this_ptr;
41087 }
41088 }
41089
41090 call->num_additional_args = 0;
41091 call->is_ctor_call = 0;
41092 EX(call) = call;
41093
41094
41095 CHECK_EXCEPTION();
41096 ZEND_VM_NEXT_OPCODE();
41097 }
41098
ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41099 static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41100 {
41101 USE_OPLINE
41102
41103
41104 SAVE_OPLINE();
41105 is_equal_function(&EX_T(opline->result.var).tmp_var,
41106 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
41107 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
41108
41109 CHECK_EXCEPTION();
41110 ZEND_VM_NEXT_OPCODE();
41111 }
41112
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41113 static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41114 {
41115 USE_OPLINE
41116
41117 zval *expr_ptr;
41118
41119 SAVE_OPLINE();
41120 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
41121 zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
41122
41123 if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
41124 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
41125 }
41126 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
41127 expr_ptr = *expr_ptr_ptr;
41128 Z_ADDREF_P(expr_ptr);
41129 } else {
41130 expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
41131 if (0) { /* temporary variable */
41132 zval *new_expr;
41133
41134 ALLOC_ZVAL(new_expr);
41135 INIT_PZVAL_COPY(new_expr, expr_ptr);
41136 expr_ptr = new_expr;
41137 } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
41138 zval *new_expr;
41139
41140 ALLOC_ZVAL(new_expr);
41141 INIT_PZVAL_COPY(new_expr, expr_ptr);
41142 expr_ptr = new_expr;
41143 zendi_zval_copy_ctor(*expr_ptr);
41144
41145 } else if (IS_CV == IS_CV) {
41146 Z_ADDREF_P(expr_ptr);
41147 }
41148 }
41149
41150 if (IS_CV != IS_UNUSED) {
41151
41152 zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
41153 ulong hval;
41154
41155 switch (Z_TYPE_P(offset)) {
41156 case IS_DOUBLE:
41157 hval = zend_dval_to_lval(Z_DVAL_P(offset));
41158 goto num_index;
41159 case IS_LONG:
41160 case IS_BOOL:
41161 hval = Z_LVAL_P(offset);
41162 num_index:
41163 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
41164 break;
41165 case IS_STRING:
41166 if (IS_CV == IS_CONST) {
41167 hval = Z_HASH_P(offset);
41168 } else {
41169 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
41170 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
41171 }
41172 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
41173 break;
41174 case IS_NULL:
41175 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
41176 break;
41177 default:
41178 zend_error(E_WARNING, "Illegal offset type");
41179 zval_ptr_dtor(&expr_ptr);
41180 /* do nothing */
41181 break;
41182 }
41183
41184 } else {
41185 if (zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL) == FAILURE) {
41186 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
41187 zval_ptr_dtor(&expr_ptr);
41188 }
41189 }
41190 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
41191
41192 }
41193 CHECK_EXCEPTION();
41194 ZEND_VM_NEXT_OPCODE();
41195 }
41196
ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41197 static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41198 {
41199 USE_OPLINE
41200
41201 array_init(&EX_T(opline->result.var).tmp_var);
41202 if (IS_CV == IS_UNUSED) {
41203 ZEND_VM_NEXT_OPCODE();
41204 #if 0 || IS_CV != IS_UNUSED
41205 } else {
41206 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
41207 #endif
41208 }
41209 }
41210
ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41211 static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41212 {
41213 USE_OPLINE
41214
41215 zval **container;
41216 zval *offset;
41217 ulong hval;
41218
41219 SAVE_OPLINE();
41220 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
41221 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
41222 SEPARATE_ZVAL_IF_NOT_REF(container);
41223 }
41224 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
41225
41226 if (IS_CV != IS_VAR || container) {
41227 switch (Z_TYPE_PP(container)) {
41228 case IS_ARRAY: {
41229 HashTable *ht = Z_ARRVAL_PP(container);
41230
41231 switch (Z_TYPE_P(offset)) {
41232 case IS_DOUBLE:
41233 hval = zend_dval_to_lval(Z_DVAL_P(offset));
41234 zend_hash_index_del(ht, hval);
41235 break;
41236 case IS_RESOURCE:
41237 case IS_BOOL:
41238 case IS_LONG:
41239 hval = Z_LVAL_P(offset);
41240 zend_hash_index_del(ht, hval);
41241 break;
41242 case IS_STRING:
41243 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
41244 Z_ADDREF_P(offset);
41245 }
41246 if (IS_CV == IS_CONST) {
41247 hval = Z_HASH_P(offset);
41248 } else {
41249 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
41250 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
41251 }
41252 if (ht == &EG(symbol_table)) {
41253 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
41254 } else {
41255 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
41256 }
41257 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
41258 zval_ptr_dtor(&offset);
41259 }
41260 break;
41261 num_index_dim:
41262 zend_hash_index_del(ht, hval);
41263 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
41264 zval_ptr_dtor(&offset);
41265 }
41266 break;
41267 case IS_NULL:
41268 zend_hash_del(ht, "", sizeof(""));
41269 break;
41270 default:
41271 zend_error(E_WARNING, "Illegal offset type in unset");
41272 break;
41273 }
41274
41275 break;
41276 }
41277 case IS_OBJECT:
41278 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
41279 zend_error_noreturn(E_ERROR, "Cannot use object as array");
41280 }
41281 if (0) {
41282 MAKE_REAL_ZVAL_PTR(offset);
41283 }
41284 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
41285 if (0) {
41286 zval_ptr_dtor(&offset);
41287 } else {
41288
41289 }
41290 break;
41291 case IS_STRING:
41292 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
41293 ZEND_VM_CONTINUE(); /* bailed out before */
41294 default:
41295
41296 break;
41297 }
41298 } else {
41299
41300 }
41301
41302 CHECK_EXCEPTION();
41303 ZEND_VM_NEXT_OPCODE();
41304 }
41305
ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41306 static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41307 {
41308 USE_OPLINE
41309
41310 zval **container;
41311 zval *offset;
41312
41313 SAVE_OPLINE();
41314 container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
41315 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
41316
41317 if (IS_CV != IS_VAR || container) {
41318 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
41319 SEPARATE_ZVAL_IF_NOT_REF(container);
41320 }
41321 if (Z_TYPE_PP(container) == IS_OBJECT) {
41322 if (0) {
41323 MAKE_REAL_ZVAL_PTR(offset);
41324 }
41325 if (Z_OBJ_HT_P(*container)->unset_property) {
41326 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
41327 } else {
41328 zend_error(E_NOTICE, "Trying to unset property of non-object");
41329 }
41330 if (0) {
41331 zval_ptr_dtor(&offset);
41332 } else {
41333
41334 }
41335 } else {
41336
41337 }
41338 } else {
41339
41340 }
41341
41342 CHECK_EXCEPTION();
41343 ZEND_VM_NEXT_OPCODE();
41344 }
41345
zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim,ZEND_OPCODE_HANDLER_ARGS)41346 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
41347 {
41348 USE_OPLINE
41349
41350 zval *container;
41351 zval **value = NULL;
41352 int result = 0;
41353 ulong hval;
41354 zval *offset;
41355
41356 SAVE_OPLINE();
41357 container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
41358 offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
41359
41360 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
41361 HashTable *ht;
41362 int isset = 0;
41363
41364 ht = Z_ARRVAL_P(container);
41365
41366 switch (Z_TYPE_P(offset)) {
41367 case IS_DOUBLE:
41368 hval = zend_dval_to_lval(Z_DVAL_P(offset));
41369 goto num_index_prop;
41370 case IS_RESOURCE:
41371 case IS_BOOL:
41372 case IS_LONG:
41373 hval = Z_LVAL_P(offset);
41374 num_index_prop:
41375 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
41376 isset = 1;
41377 }
41378 break;
41379 case IS_STRING:
41380 if (IS_CV == IS_CONST) {
41381 hval = Z_HASH_P(offset);
41382 } else {
41383 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
41384 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
41385 }
41386 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
41387 isset = 1;
41388 }
41389 break;
41390 case IS_NULL:
41391 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
41392 isset = 1;
41393 }
41394 break;
41395 default:
41396 zend_error(E_WARNING, "Illegal offset type in isset or empty");
41397 break;
41398 }
41399
41400 if (opline->extended_value & ZEND_ISSET) {
41401 if (isset && Z_TYPE_PP(value) == IS_NULL) {
41402 result = 0;
41403 } else {
41404 result = isset;
41405 }
41406 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
41407 if (!isset || !i_zend_is_true(*value)) {
41408 result = 0;
41409 } else {
41410 result = 1;
41411 }
41412 }
41413
41414 } else if (Z_TYPE_P(container) == IS_OBJECT) {
41415 if (0) {
41416 MAKE_REAL_ZVAL_PTR(offset);
41417 }
41418 if (prop_dim) {
41419 if (Z_OBJ_HT_P(container)->has_property) {
41420 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
41421 } else {
41422 zend_error(E_NOTICE, "Trying to check property of non-object");
41423 result = 0;
41424 }
41425 } else {
41426 if (Z_OBJ_HT_P(container)->has_dimension) {
41427 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
41428 } else {
41429 zend_error(E_NOTICE, "Trying to check element of non-array");
41430 result = 0;
41431 }
41432 }
41433 if (0) {
41434 zval_ptr_dtor(&offset);
41435 } else {
41436
41437 }
41438 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
41439 zval tmp;
41440
41441 if (Z_TYPE_P(offset) != IS_LONG) {
41442 if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
41443 || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
41444 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
41445 ZVAL_COPY_VALUE(&tmp, offset);
41446 zval_copy_ctor(&tmp);
41447 convert_to_long(&tmp);
41448 offset = &tmp;
41449 } else {
41450 /* can not be converted to proper offset, return "not set" */
41451 result = 0;
41452 }
41453 }
41454 if (Z_TYPE_P(offset) == IS_LONG) {
41455 if (opline->extended_value & ZEND_ISSET) {
41456 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
41457 result = 1;
41458 }
41459 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
41460 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
41461 result = 1;
41462 }
41463 }
41464 }
41465
41466 } else {
41467
41468 }
41469
41470 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
41471 if (opline->extended_value & ZEND_ISSET) {
41472 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
41473 } else {
41474 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
41475 }
41476
41477 CHECK_EXCEPTION();
41478 ZEND_VM_NEXT_OPCODE();
41479 }
41480
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41481 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41482 {
41483 return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
41484 }
41485
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41486 static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41487 {
41488 return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
41489 }
41490
ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41491 static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41492 {
41493 USE_OPLINE
41494
41495 /* The generator object is stored in return_value_ptr_ptr */
41496 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
41497
41498 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
41499 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
41500 }
41501
41502 /* Destroy the previously yielded value */
41503 if (generator->value) {
41504 zval_ptr_dtor(&generator->value);
41505 }
41506
41507 /* Destroy the previously yielded key */
41508 if (generator->key) {
41509 zval_ptr_dtor(&generator->key);
41510 }
41511
41512 /* Set the new yielded value */
41513 if (IS_CV != IS_UNUSED) {
41514
41515
41516 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
41517 /* Constants and temporary variables aren't yieldable by reference,
41518 * but we still allow them with a notice. */
41519 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
41520 zval *value, *copy;
41521
41522 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
41523
41524 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
41525 ALLOC_ZVAL(copy);
41526 INIT_PZVAL_COPY(copy, value);
41527
41528 /* Temporary variables don't need ctor copying */
41529 if (!0) {
41530 zval_copy_ctor(copy);
41531 }
41532
41533 generator->value = copy;
41534 } else {
41535 zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
41536
41537 if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
41538 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
41539 }
41540
41541 /* If a function call result is yielded and the function did
41542 * not return by reference we throw a notice. */
41543 if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
41544 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
41545 && EX_T(opline->op1.var).var.fcall_returned_reference)
41546 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
41547 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
41548
41549 Z_ADDREF_PP(value_ptr);
41550 generator->value = *value_ptr;
41551 } else {
41552 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
41553 Z_ADDREF_PP(value_ptr);
41554 generator->value = *value_ptr;
41555 }
41556
41557 }
41558 } else {
41559 zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
41560
41561 /* Consts, temporary variables and references need copying */
41562 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
41563 || PZVAL_IS_REF(value)
41564 ) {
41565 zval *copy;
41566
41567 ALLOC_ZVAL(copy);
41568 INIT_PZVAL_COPY(copy, value);
41569
41570 /* Temporary variables don't need ctor copying */
41571 if (!0) {
41572 zval_copy_ctor(copy);
41573 }
41574
41575 generator->value = copy;
41576
41577 } else {
41578 if (IS_CV == IS_CV) {
41579 Z_ADDREF_P(value);
41580 }
41581 generator->value = value;
41582 }
41583 }
41584 } else {
41585 /* If no value was specified yield null */
41586 Z_ADDREF(EG(uninitialized_zval));
41587 generator->value = &EG(uninitialized_zval);
41588 }
41589
41590 /* Set the new yielded key */
41591 if (IS_CV != IS_UNUSED) {
41592
41593 zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
41594
41595 /* Consts, temporary variables and references need copying */
41596 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
41597 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
41598 ) {
41599 zval *copy;
41600
41601 ALLOC_ZVAL(copy);
41602 INIT_PZVAL_COPY(copy, key);
41603
41604 /* Temporary variables don't need ctor copying */
41605 if (!0) {
41606 zval_copy_ctor(copy);
41607 }
41608
41609 generator->key = copy;
41610 } else {
41611 Z_ADDREF_P(key);
41612 generator->key = key;
41613 }
41614
41615 if (Z_TYPE_P(generator->key) == IS_LONG
41616 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
41617 ) {
41618 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
41619 }
41620
41621 } else {
41622 /* If no key was specified we use auto-increment keys */
41623 generator->largest_used_integer_key++;
41624
41625 ALLOC_INIT_ZVAL(generator->key);
41626 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
41627 }
41628
41629 if (RETURN_VALUE_USED(opline)) {
41630 /* If the return value of yield is used set the send
41631 * target and initialize it to NULL */
41632 generator->send_target = &EX_T(opline->result.var).var.ptr;
41633 Z_ADDREF(EG(uninitialized_zval));
41634 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
41635 } else {
41636 generator->send_target = NULL;
41637 }
41638
41639 /* We increment to the next op, so we are at the correct position when the
41640 * generator is resumed. */
41641 ZEND_VM_INC_OPCODE();
41642
41643 /* The GOTO VM uses a local opline variable. We need to set the opline
41644 * variable in execute_data so we don't resume at an old position. */
41645 SAVE_OPLINE();
41646
41647 ZEND_VM_RETURN();
41648 }
41649
ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41650 static int ZEND_FASTCALL ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41651 {
41652 USE_OPLINE
41653
41654
41655 SAVE_OPLINE();
41656 pow_function(&EX_T(opline->result.var).tmp_var,
41657 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
41658 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
41659
41660
41661 CHECK_EXCEPTION();
41662 ZEND_VM_NEXT_OPCODE();
41663 }
41664
ZEND_ASSIGN_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41665 static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41666 {
41667 return zend_binary_assign_op_helper_SPEC_CV_CV(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
41668 }
41669
ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41670 static int ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41671 {
41672 zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);
41673 ZEND_VM_NEXT_OPCODE(); /* Never reached */
41674 }
41675
41676
zend_init_opcodes_handlers(void)41677 void zend_init_opcodes_handlers(void)
41678 {
41679 static const opcode_handler_t labels[] = {
41680 ZEND_NOP_SPEC_HANDLER,
41681 ZEND_NOP_SPEC_HANDLER,
41682 ZEND_NOP_SPEC_HANDLER,
41683 ZEND_NOP_SPEC_HANDLER,
41684 ZEND_NOP_SPEC_HANDLER,
41685 ZEND_NOP_SPEC_HANDLER,
41686 ZEND_NOP_SPEC_HANDLER,
41687 ZEND_NOP_SPEC_HANDLER,
41688 ZEND_NOP_SPEC_HANDLER,
41689 ZEND_NOP_SPEC_HANDLER,
41690 ZEND_NOP_SPEC_HANDLER,
41691 ZEND_NOP_SPEC_HANDLER,
41692 ZEND_NOP_SPEC_HANDLER,
41693 ZEND_NOP_SPEC_HANDLER,
41694 ZEND_NOP_SPEC_HANDLER,
41695 ZEND_NOP_SPEC_HANDLER,
41696 ZEND_NOP_SPEC_HANDLER,
41697 ZEND_NOP_SPEC_HANDLER,
41698 ZEND_NOP_SPEC_HANDLER,
41699 ZEND_NOP_SPEC_HANDLER,
41700 ZEND_NOP_SPEC_HANDLER,
41701 ZEND_NOP_SPEC_HANDLER,
41702 ZEND_NOP_SPEC_HANDLER,
41703 ZEND_NOP_SPEC_HANDLER,
41704 ZEND_NOP_SPEC_HANDLER,
41705 ZEND_ADD_SPEC_CONST_CONST_HANDLER,
41706 ZEND_ADD_SPEC_CONST_TMP_HANDLER,
41707 ZEND_ADD_SPEC_CONST_VAR_HANDLER,
41708 ZEND_NULL_HANDLER,
41709 ZEND_ADD_SPEC_CONST_CV_HANDLER,
41710 ZEND_ADD_SPEC_TMP_CONST_HANDLER,
41711 ZEND_ADD_SPEC_TMP_TMP_HANDLER,
41712 ZEND_ADD_SPEC_TMP_VAR_HANDLER,
41713 ZEND_NULL_HANDLER,
41714 ZEND_ADD_SPEC_TMP_CV_HANDLER,
41715 ZEND_ADD_SPEC_VAR_CONST_HANDLER,
41716 ZEND_ADD_SPEC_VAR_TMP_HANDLER,
41717 ZEND_ADD_SPEC_VAR_VAR_HANDLER,
41718 ZEND_NULL_HANDLER,
41719 ZEND_ADD_SPEC_VAR_CV_HANDLER,
41720 ZEND_NULL_HANDLER,
41721 ZEND_NULL_HANDLER,
41722 ZEND_NULL_HANDLER,
41723 ZEND_NULL_HANDLER,
41724 ZEND_NULL_HANDLER,
41725 ZEND_ADD_SPEC_CV_CONST_HANDLER,
41726 ZEND_ADD_SPEC_CV_TMP_HANDLER,
41727 ZEND_ADD_SPEC_CV_VAR_HANDLER,
41728 ZEND_NULL_HANDLER,
41729 ZEND_ADD_SPEC_CV_CV_HANDLER,
41730 ZEND_SUB_SPEC_CONST_CONST_HANDLER,
41731 ZEND_SUB_SPEC_CONST_TMP_HANDLER,
41732 ZEND_SUB_SPEC_CONST_VAR_HANDLER,
41733 ZEND_NULL_HANDLER,
41734 ZEND_SUB_SPEC_CONST_CV_HANDLER,
41735 ZEND_SUB_SPEC_TMP_CONST_HANDLER,
41736 ZEND_SUB_SPEC_TMP_TMP_HANDLER,
41737 ZEND_SUB_SPEC_TMP_VAR_HANDLER,
41738 ZEND_NULL_HANDLER,
41739 ZEND_SUB_SPEC_TMP_CV_HANDLER,
41740 ZEND_SUB_SPEC_VAR_CONST_HANDLER,
41741 ZEND_SUB_SPEC_VAR_TMP_HANDLER,
41742 ZEND_SUB_SPEC_VAR_VAR_HANDLER,
41743 ZEND_NULL_HANDLER,
41744 ZEND_SUB_SPEC_VAR_CV_HANDLER,
41745 ZEND_NULL_HANDLER,
41746 ZEND_NULL_HANDLER,
41747 ZEND_NULL_HANDLER,
41748 ZEND_NULL_HANDLER,
41749 ZEND_NULL_HANDLER,
41750 ZEND_SUB_SPEC_CV_CONST_HANDLER,
41751 ZEND_SUB_SPEC_CV_TMP_HANDLER,
41752 ZEND_SUB_SPEC_CV_VAR_HANDLER,
41753 ZEND_NULL_HANDLER,
41754 ZEND_SUB_SPEC_CV_CV_HANDLER,
41755 ZEND_MUL_SPEC_CONST_CONST_HANDLER,
41756 ZEND_MUL_SPEC_CONST_TMP_HANDLER,
41757 ZEND_MUL_SPEC_CONST_VAR_HANDLER,
41758 ZEND_NULL_HANDLER,
41759 ZEND_MUL_SPEC_CONST_CV_HANDLER,
41760 ZEND_MUL_SPEC_TMP_CONST_HANDLER,
41761 ZEND_MUL_SPEC_TMP_TMP_HANDLER,
41762 ZEND_MUL_SPEC_TMP_VAR_HANDLER,
41763 ZEND_NULL_HANDLER,
41764 ZEND_MUL_SPEC_TMP_CV_HANDLER,
41765 ZEND_MUL_SPEC_VAR_CONST_HANDLER,
41766 ZEND_MUL_SPEC_VAR_TMP_HANDLER,
41767 ZEND_MUL_SPEC_VAR_VAR_HANDLER,
41768 ZEND_NULL_HANDLER,
41769 ZEND_MUL_SPEC_VAR_CV_HANDLER,
41770 ZEND_NULL_HANDLER,
41771 ZEND_NULL_HANDLER,
41772 ZEND_NULL_HANDLER,
41773 ZEND_NULL_HANDLER,
41774 ZEND_NULL_HANDLER,
41775 ZEND_MUL_SPEC_CV_CONST_HANDLER,
41776 ZEND_MUL_SPEC_CV_TMP_HANDLER,
41777 ZEND_MUL_SPEC_CV_VAR_HANDLER,
41778 ZEND_NULL_HANDLER,
41779 ZEND_MUL_SPEC_CV_CV_HANDLER,
41780 ZEND_DIV_SPEC_CONST_CONST_HANDLER,
41781 ZEND_DIV_SPEC_CONST_TMP_HANDLER,
41782 ZEND_DIV_SPEC_CONST_VAR_HANDLER,
41783 ZEND_NULL_HANDLER,
41784 ZEND_DIV_SPEC_CONST_CV_HANDLER,
41785 ZEND_DIV_SPEC_TMP_CONST_HANDLER,
41786 ZEND_DIV_SPEC_TMP_TMP_HANDLER,
41787 ZEND_DIV_SPEC_TMP_VAR_HANDLER,
41788 ZEND_NULL_HANDLER,
41789 ZEND_DIV_SPEC_TMP_CV_HANDLER,
41790 ZEND_DIV_SPEC_VAR_CONST_HANDLER,
41791 ZEND_DIV_SPEC_VAR_TMP_HANDLER,
41792 ZEND_DIV_SPEC_VAR_VAR_HANDLER,
41793 ZEND_NULL_HANDLER,
41794 ZEND_DIV_SPEC_VAR_CV_HANDLER,
41795 ZEND_NULL_HANDLER,
41796 ZEND_NULL_HANDLER,
41797 ZEND_NULL_HANDLER,
41798 ZEND_NULL_HANDLER,
41799 ZEND_NULL_HANDLER,
41800 ZEND_DIV_SPEC_CV_CONST_HANDLER,
41801 ZEND_DIV_SPEC_CV_TMP_HANDLER,
41802 ZEND_DIV_SPEC_CV_VAR_HANDLER,
41803 ZEND_NULL_HANDLER,
41804 ZEND_DIV_SPEC_CV_CV_HANDLER,
41805 ZEND_MOD_SPEC_CONST_CONST_HANDLER,
41806 ZEND_MOD_SPEC_CONST_TMP_HANDLER,
41807 ZEND_MOD_SPEC_CONST_VAR_HANDLER,
41808 ZEND_NULL_HANDLER,
41809 ZEND_MOD_SPEC_CONST_CV_HANDLER,
41810 ZEND_MOD_SPEC_TMP_CONST_HANDLER,
41811 ZEND_MOD_SPEC_TMP_TMP_HANDLER,
41812 ZEND_MOD_SPEC_TMP_VAR_HANDLER,
41813 ZEND_NULL_HANDLER,
41814 ZEND_MOD_SPEC_TMP_CV_HANDLER,
41815 ZEND_MOD_SPEC_VAR_CONST_HANDLER,
41816 ZEND_MOD_SPEC_VAR_TMP_HANDLER,
41817 ZEND_MOD_SPEC_VAR_VAR_HANDLER,
41818 ZEND_NULL_HANDLER,
41819 ZEND_MOD_SPEC_VAR_CV_HANDLER,
41820 ZEND_NULL_HANDLER,
41821 ZEND_NULL_HANDLER,
41822 ZEND_NULL_HANDLER,
41823 ZEND_NULL_HANDLER,
41824 ZEND_NULL_HANDLER,
41825 ZEND_MOD_SPEC_CV_CONST_HANDLER,
41826 ZEND_MOD_SPEC_CV_TMP_HANDLER,
41827 ZEND_MOD_SPEC_CV_VAR_HANDLER,
41828 ZEND_NULL_HANDLER,
41829 ZEND_MOD_SPEC_CV_CV_HANDLER,
41830 ZEND_SL_SPEC_CONST_CONST_HANDLER,
41831 ZEND_SL_SPEC_CONST_TMP_HANDLER,
41832 ZEND_SL_SPEC_CONST_VAR_HANDLER,
41833 ZEND_NULL_HANDLER,
41834 ZEND_SL_SPEC_CONST_CV_HANDLER,
41835 ZEND_SL_SPEC_TMP_CONST_HANDLER,
41836 ZEND_SL_SPEC_TMP_TMP_HANDLER,
41837 ZEND_SL_SPEC_TMP_VAR_HANDLER,
41838 ZEND_NULL_HANDLER,
41839 ZEND_SL_SPEC_TMP_CV_HANDLER,
41840 ZEND_SL_SPEC_VAR_CONST_HANDLER,
41841 ZEND_SL_SPEC_VAR_TMP_HANDLER,
41842 ZEND_SL_SPEC_VAR_VAR_HANDLER,
41843 ZEND_NULL_HANDLER,
41844 ZEND_SL_SPEC_VAR_CV_HANDLER,
41845 ZEND_NULL_HANDLER,
41846 ZEND_NULL_HANDLER,
41847 ZEND_NULL_HANDLER,
41848 ZEND_NULL_HANDLER,
41849 ZEND_NULL_HANDLER,
41850 ZEND_SL_SPEC_CV_CONST_HANDLER,
41851 ZEND_SL_SPEC_CV_TMP_HANDLER,
41852 ZEND_SL_SPEC_CV_VAR_HANDLER,
41853 ZEND_NULL_HANDLER,
41854 ZEND_SL_SPEC_CV_CV_HANDLER,
41855 ZEND_SR_SPEC_CONST_CONST_HANDLER,
41856 ZEND_SR_SPEC_CONST_TMP_HANDLER,
41857 ZEND_SR_SPEC_CONST_VAR_HANDLER,
41858 ZEND_NULL_HANDLER,
41859 ZEND_SR_SPEC_CONST_CV_HANDLER,
41860 ZEND_SR_SPEC_TMP_CONST_HANDLER,
41861 ZEND_SR_SPEC_TMP_TMP_HANDLER,
41862 ZEND_SR_SPEC_TMP_VAR_HANDLER,
41863 ZEND_NULL_HANDLER,
41864 ZEND_SR_SPEC_TMP_CV_HANDLER,
41865 ZEND_SR_SPEC_VAR_CONST_HANDLER,
41866 ZEND_SR_SPEC_VAR_TMP_HANDLER,
41867 ZEND_SR_SPEC_VAR_VAR_HANDLER,
41868 ZEND_NULL_HANDLER,
41869 ZEND_SR_SPEC_VAR_CV_HANDLER,
41870 ZEND_NULL_HANDLER,
41871 ZEND_NULL_HANDLER,
41872 ZEND_NULL_HANDLER,
41873 ZEND_NULL_HANDLER,
41874 ZEND_NULL_HANDLER,
41875 ZEND_SR_SPEC_CV_CONST_HANDLER,
41876 ZEND_SR_SPEC_CV_TMP_HANDLER,
41877 ZEND_SR_SPEC_CV_VAR_HANDLER,
41878 ZEND_NULL_HANDLER,
41879 ZEND_SR_SPEC_CV_CV_HANDLER,
41880 ZEND_CONCAT_SPEC_CONST_CONST_HANDLER,
41881 ZEND_CONCAT_SPEC_CONST_TMP_HANDLER,
41882 ZEND_CONCAT_SPEC_CONST_VAR_HANDLER,
41883 ZEND_NULL_HANDLER,
41884 ZEND_CONCAT_SPEC_CONST_CV_HANDLER,
41885 ZEND_CONCAT_SPEC_TMP_CONST_HANDLER,
41886 ZEND_CONCAT_SPEC_TMP_TMP_HANDLER,
41887 ZEND_CONCAT_SPEC_TMP_VAR_HANDLER,
41888 ZEND_NULL_HANDLER,
41889 ZEND_CONCAT_SPEC_TMP_CV_HANDLER,
41890 ZEND_CONCAT_SPEC_VAR_CONST_HANDLER,
41891 ZEND_CONCAT_SPEC_VAR_TMP_HANDLER,
41892 ZEND_CONCAT_SPEC_VAR_VAR_HANDLER,
41893 ZEND_NULL_HANDLER,
41894 ZEND_CONCAT_SPEC_VAR_CV_HANDLER,
41895 ZEND_NULL_HANDLER,
41896 ZEND_NULL_HANDLER,
41897 ZEND_NULL_HANDLER,
41898 ZEND_NULL_HANDLER,
41899 ZEND_NULL_HANDLER,
41900 ZEND_CONCAT_SPEC_CV_CONST_HANDLER,
41901 ZEND_CONCAT_SPEC_CV_TMP_HANDLER,
41902 ZEND_CONCAT_SPEC_CV_VAR_HANDLER,
41903 ZEND_NULL_HANDLER,
41904 ZEND_CONCAT_SPEC_CV_CV_HANDLER,
41905 ZEND_BW_OR_SPEC_CONST_CONST_HANDLER,
41906 ZEND_BW_OR_SPEC_CONST_TMP_HANDLER,
41907 ZEND_BW_OR_SPEC_CONST_VAR_HANDLER,
41908 ZEND_NULL_HANDLER,
41909 ZEND_BW_OR_SPEC_CONST_CV_HANDLER,
41910 ZEND_BW_OR_SPEC_TMP_CONST_HANDLER,
41911 ZEND_BW_OR_SPEC_TMP_TMP_HANDLER,
41912 ZEND_BW_OR_SPEC_TMP_VAR_HANDLER,
41913 ZEND_NULL_HANDLER,
41914 ZEND_BW_OR_SPEC_TMP_CV_HANDLER,
41915 ZEND_BW_OR_SPEC_VAR_CONST_HANDLER,
41916 ZEND_BW_OR_SPEC_VAR_TMP_HANDLER,
41917 ZEND_BW_OR_SPEC_VAR_VAR_HANDLER,
41918 ZEND_NULL_HANDLER,
41919 ZEND_BW_OR_SPEC_VAR_CV_HANDLER,
41920 ZEND_NULL_HANDLER,
41921 ZEND_NULL_HANDLER,
41922 ZEND_NULL_HANDLER,
41923 ZEND_NULL_HANDLER,
41924 ZEND_NULL_HANDLER,
41925 ZEND_BW_OR_SPEC_CV_CONST_HANDLER,
41926 ZEND_BW_OR_SPEC_CV_TMP_HANDLER,
41927 ZEND_BW_OR_SPEC_CV_VAR_HANDLER,
41928 ZEND_NULL_HANDLER,
41929 ZEND_BW_OR_SPEC_CV_CV_HANDLER,
41930 ZEND_BW_AND_SPEC_CONST_CONST_HANDLER,
41931 ZEND_BW_AND_SPEC_CONST_TMP_HANDLER,
41932 ZEND_BW_AND_SPEC_CONST_VAR_HANDLER,
41933 ZEND_NULL_HANDLER,
41934 ZEND_BW_AND_SPEC_CONST_CV_HANDLER,
41935 ZEND_BW_AND_SPEC_TMP_CONST_HANDLER,
41936 ZEND_BW_AND_SPEC_TMP_TMP_HANDLER,
41937 ZEND_BW_AND_SPEC_TMP_VAR_HANDLER,
41938 ZEND_NULL_HANDLER,
41939 ZEND_BW_AND_SPEC_TMP_CV_HANDLER,
41940 ZEND_BW_AND_SPEC_VAR_CONST_HANDLER,
41941 ZEND_BW_AND_SPEC_VAR_TMP_HANDLER,
41942 ZEND_BW_AND_SPEC_VAR_VAR_HANDLER,
41943 ZEND_NULL_HANDLER,
41944 ZEND_BW_AND_SPEC_VAR_CV_HANDLER,
41945 ZEND_NULL_HANDLER,
41946 ZEND_NULL_HANDLER,
41947 ZEND_NULL_HANDLER,
41948 ZEND_NULL_HANDLER,
41949 ZEND_NULL_HANDLER,
41950 ZEND_BW_AND_SPEC_CV_CONST_HANDLER,
41951 ZEND_BW_AND_SPEC_CV_TMP_HANDLER,
41952 ZEND_BW_AND_SPEC_CV_VAR_HANDLER,
41953 ZEND_NULL_HANDLER,
41954 ZEND_BW_AND_SPEC_CV_CV_HANDLER,
41955 ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER,
41956 ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER,
41957 ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER,
41958 ZEND_NULL_HANDLER,
41959 ZEND_BW_XOR_SPEC_CONST_CV_HANDLER,
41960 ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER,
41961 ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER,
41962 ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER,
41963 ZEND_NULL_HANDLER,
41964 ZEND_BW_XOR_SPEC_TMP_CV_HANDLER,
41965 ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER,
41966 ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER,
41967 ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER,
41968 ZEND_NULL_HANDLER,
41969 ZEND_BW_XOR_SPEC_VAR_CV_HANDLER,
41970 ZEND_NULL_HANDLER,
41971 ZEND_NULL_HANDLER,
41972 ZEND_NULL_HANDLER,
41973 ZEND_NULL_HANDLER,
41974 ZEND_NULL_HANDLER,
41975 ZEND_BW_XOR_SPEC_CV_CONST_HANDLER,
41976 ZEND_BW_XOR_SPEC_CV_TMP_HANDLER,
41977 ZEND_BW_XOR_SPEC_CV_VAR_HANDLER,
41978 ZEND_NULL_HANDLER,
41979 ZEND_BW_XOR_SPEC_CV_CV_HANDLER,
41980 ZEND_BW_NOT_SPEC_CONST_HANDLER,
41981 ZEND_BW_NOT_SPEC_CONST_HANDLER,
41982 ZEND_BW_NOT_SPEC_CONST_HANDLER,
41983 ZEND_BW_NOT_SPEC_CONST_HANDLER,
41984 ZEND_BW_NOT_SPEC_CONST_HANDLER,
41985 ZEND_BW_NOT_SPEC_TMP_HANDLER,
41986 ZEND_BW_NOT_SPEC_TMP_HANDLER,
41987 ZEND_BW_NOT_SPEC_TMP_HANDLER,
41988 ZEND_BW_NOT_SPEC_TMP_HANDLER,
41989 ZEND_BW_NOT_SPEC_TMP_HANDLER,
41990 ZEND_BW_NOT_SPEC_VAR_HANDLER,
41991 ZEND_BW_NOT_SPEC_VAR_HANDLER,
41992 ZEND_BW_NOT_SPEC_VAR_HANDLER,
41993 ZEND_BW_NOT_SPEC_VAR_HANDLER,
41994 ZEND_BW_NOT_SPEC_VAR_HANDLER,
41995 ZEND_NULL_HANDLER,
41996 ZEND_NULL_HANDLER,
41997 ZEND_NULL_HANDLER,
41998 ZEND_NULL_HANDLER,
41999 ZEND_NULL_HANDLER,
42000 ZEND_BW_NOT_SPEC_CV_HANDLER,
42001 ZEND_BW_NOT_SPEC_CV_HANDLER,
42002 ZEND_BW_NOT_SPEC_CV_HANDLER,
42003 ZEND_BW_NOT_SPEC_CV_HANDLER,
42004 ZEND_BW_NOT_SPEC_CV_HANDLER,
42005 ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
42006 ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
42007 ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
42008 ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
42009 ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
42010 ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
42011 ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
42012 ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
42013 ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
42014 ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
42015 ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
42016 ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
42017 ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
42018 ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
42019 ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
42020 ZEND_NULL_HANDLER,
42021 ZEND_NULL_HANDLER,
42022 ZEND_NULL_HANDLER,
42023 ZEND_NULL_HANDLER,
42024 ZEND_NULL_HANDLER,
42025 ZEND_BOOL_NOT_SPEC_CV_HANDLER,
42026 ZEND_BOOL_NOT_SPEC_CV_HANDLER,
42027 ZEND_BOOL_NOT_SPEC_CV_HANDLER,
42028 ZEND_BOOL_NOT_SPEC_CV_HANDLER,
42029 ZEND_BOOL_NOT_SPEC_CV_HANDLER,
42030 ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER,
42031 ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER,
42032 ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER,
42033 ZEND_NULL_HANDLER,
42034 ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER,
42035 ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER,
42036 ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER,
42037 ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER,
42038 ZEND_NULL_HANDLER,
42039 ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER,
42040 ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER,
42041 ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER,
42042 ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER,
42043 ZEND_NULL_HANDLER,
42044 ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER,
42045 ZEND_NULL_HANDLER,
42046 ZEND_NULL_HANDLER,
42047 ZEND_NULL_HANDLER,
42048 ZEND_NULL_HANDLER,
42049 ZEND_NULL_HANDLER,
42050 ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER,
42051 ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER,
42052 ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER,
42053 ZEND_NULL_HANDLER,
42054 ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER,
42055 ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER,
42056 ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER,
42057 ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER,
42058 ZEND_NULL_HANDLER,
42059 ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER,
42060 ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER,
42061 ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER,
42062 ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER,
42063 ZEND_NULL_HANDLER,
42064 ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER,
42065 ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER,
42066 ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER,
42067 ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER,
42068 ZEND_NULL_HANDLER,
42069 ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER,
42070 ZEND_NULL_HANDLER,
42071 ZEND_NULL_HANDLER,
42072 ZEND_NULL_HANDLER,
42073 ZEND_NULL_HANDLER,
42074 ZEND_NULL_HANDLER,
42075 ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER,
42076 ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER,
42077 ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER,
42078 ZEND_NULL_HANDLER,
42079 ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER,
42080 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER,
42081 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER,
42082 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER,
42083 ZEND_NULL_HANDLER,
42084 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER,
42085 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER,
42086 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER,
42087 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER,
42088 ZEND_NULL_HANDLER,
42089 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER,
42090 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER,
42091 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER,
42092 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER,
42093 ZEND_NULL_HANDLER,
42094 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER,
42095 ZEND_NULL_HANDLER,
42096 ZEND_NULL_HANDLER,
42097 ZEND_NULL_HANDLER,
42098 ZEND_NULL_HANDLER,
42099 ZEND_NULL_HANDLER,
42100 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER,
42101 ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER,
42102 ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER,
42103 ZEND_NULL_HANDLER,
42104 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER,
42105 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
42106 ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER,
42107 ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER,
42108 ZEND_NULL_HANDLER,
42109 ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER,
42110 ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER,
42111 ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER,
42112 ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER,
42113 ZEND_NULL_HANDLER,
42114 ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER,
42115 ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER,
42116 ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER,
42117 ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER,
42118 ZEND_NULL_HANDLER,
42119 ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER,
42120 ZEND_NULL_HANDLER,
42121 ZEND_NULL_HANDLER,
42122 ZEND_NULL_HANDLER,
42123 ZEND_NULL_HANDLER,
42124 ZEND_NULL_HANDLER,
42125 ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER,
42126 ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER,
42127 ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER,
42128 ZEND_NULL_HANDLER,
42129 ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER,
42130 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
42131 ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER,
42132 ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER,
42133 ZEND_NULL_HANDLER,
42134 ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER,
42135 ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER,
42136 ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER,
42137 ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER,
42138 ZEND_NULL_HANDLER,
42139 ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER,
42140 ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER,
42141 ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER,
42142 ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER,
42143 ZEND_NULL_HANDLER,
42144 ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER,
42145 ZEND_NULL_HANDLER,
42146 ZEND_NULL_HANDLER,
42147 ZEND_NULL_HANDLER,
42148 ZEND_NULL_HANDLER,
42149 ZEND_NULL_HANDLER,
42150 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER,
42151 ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER,
42152 ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER,
42153 ZEND_NULL_HANDLER,
42154 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
42155 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
42156 ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER,
42157 ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER,
42158 ZEND_NULL_HANDLER,
42159 ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER,
42160 ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER,
42161 ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER,
42162 ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER,
42163 ZEND_NULL_HANDLER,
42164 ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER,
42165 ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER,
42166 ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER,
42167 ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER,
42168 ZEND_NULL_HANDLER,
42169 ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER,
42170 ZEND_NULL_HANDLER,
42171 ZEND_NULL_HANDLER,
42172 ZEND_NULL_HANDLER,
42173 ZEND_NULL_HANDLER,
42174 ZEND_NULL_HANDLER,
42175 ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER,
42176 ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER,
42177 ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER,
42178 ZEND_NULL_HANDLER,
42179 ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER,
42180 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
42181 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER,
42182 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER,
42183 ZEND_NULL_HANDLER,
42184 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER,
42185 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER,
42186 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER,
42187 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER,
42188 ZEND_NULL_HANDLER,
42189 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER,
42190 ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER,
42191 ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER,
42192 ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER,
42193 ZEND_NULL_HANDLER,
42194 ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER,
42195 ZEND_NULL_HANDLER,
42196 ZEND_NULL_HANDLER,
42197 ZEND_NULL_HANDLER,
42198 ZEND_NULL_HANDLER,
42199 ZEND_NULL_HANDLER,
42200 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER,
42201 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER,
42202 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER,
42203 ZEND_NULL_HANDLER,
42204 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER,
42205 ZEND_CAST_SPEC_CONST_HANDLER,
42206 ZEND_CAST_SPEC_CONST_HANDLER,
42207 ZEND_CAST_SPEC_CONST_HANDLER,
42208 ZEND_CAST_SPEC_CONST_HANDLER,
42209 ZEND_CAST_SPEC_CONST_HANDLER,
42210 ZEND_CAST_SPEC_TMP_HANDLER,
42211 ZEND_CAST_SPEC_TMP_HANDLER,
42212 ZEND_CAST_SPEC_TMP_HANDLER,
42213 ZEND_CAST_SPEC_TMP_HANDLER,
42214 ZEND_CAST_SPEC_TMP_HANDLER,
42215 ZEND_CAST_SPEC_VAR_HANDLER,
42216 ZEND_CAST_SPEC_VAR_HANDLER,
42217 ZEND_CAST_SPEC_VAR_HANDLER,
42218 ZEND_CAST_SPEC_VAR_HANDLER,
42219 ZEND_CAST_SPEC_VAR_HANDLER,
42220 ZEND_NULL_HANDLER,
42221 ZEND_NULL_HANDLER,
42222 ZEND_NULL_HANDLER,
42223 ZEND_NULL_HANDLER,
42224 ZEND_NULL_HANDLER,
42225 ZEND_CAST_SPEC_CV_HANDLER,
42226 ZEND_CAST_SPEC_CV_HANDLER,
42227 ZEND_CAST_SPEC_CV_HANDLER,
42228 ZEND_CAST_SPEC_CV_HANDLER,
42229 ZEND_CAST_SPEC_CV_HANDLER,
42230 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
42231 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
42232 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
42233 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
42234 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
42235 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
42236 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
42237 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
42238 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
42239 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
42240 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
42241 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
42242 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
42243 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
42244 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
42245 ZEND_NULL_HANDLER,
42246 ZEND_NULL_HANDLER,
42247 ZEND_NULL_HANDLER,
42248 ZEND_NULL_HANDLER,
42249 ZEND_NULL_HANDLER,
42250 ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
42251 ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
42252 ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
42253 ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
42254 ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
42255 ZEND_NULL_HANDLER,
42256 ZEND_NULL_HANDLER,
42257 ZEND_NULL_HANDLER,
42258 ZEND_NULL_HANDLER,
42259 ZEND_NULL_HANDLER,
42260 ZEND_NULL_HANDLER,
42261 ZEND_NULL_HANDLER,
42262 ZEND_NULL_HANDLER,
42263 ZEND_NULL_HANDLER,
42264 ZEND_NULL_HANDLER,
42265 ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER,
42266 ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER,
42267 ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER,
42268 ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER,
42269 ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER,
42270 ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER,
42271 ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER,
42272 ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER,
42273 ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER,
42274 ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER,
42275 ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER,
42276 ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER,
42277 ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER,
42278 ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER,
42279 ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER,
42280 ZEND_NULL_HANDLER,
42281 ZEND_NULL_HANDLER,
42282 ZEND_NULL_HANDLER,
42283 ZEND_NULL_HANDLER,
42284 ZEND_NULL_HANDLER,
42285 ZEND_NULL_HANDLER,
42286 ZEND_NULL_HANDLER,
42287 ZEND_NULL_HANDLER,
42288 ZEND_NULL_HANDLER,
42289 ZEND_NULL_HANDLER,
42290 ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER,
42291 ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER,
42292 ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER,
42293 ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER,
42294 ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER,
42295 ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER,
42296 ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER,
42297 ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER,
42298 ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER,
42299 ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER,
42300 ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER,
42301 ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER,
42302 ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER,
42303 ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER,
42304 ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER,
42305 ZEND_NULL_HANDLER,
42306 ZEND_NULL_HANDLER,
42307 ZEND_NULL_HANDLER,
42308 ZEND_NULL_HANDLER,
42309 ZEND_NULL_HANDLER,
42310 ZEND_NULL_HANDLER,
42311 ZEND_NULL_HANDLER,
42312 ZEND_NULL_HANDLER,
42313 ZEND_NULL_HANDLER,
42314 ZEND_NULL_HANDLER,
42315 ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER,
42316 ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER,
42317 ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER,
42318 ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER,
42319 ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER,
42320 ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER,
42321 ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER,
42322 ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER,
42323 ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER,
42324 ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER,
42325 ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER,
42326 ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER,
42327 ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER,
42328 ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER,
42329 ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER,
42330 ZEND_NULL_HANDLER,
42331 ZEND_NULL_HANDLER,
42332 ZEND_NULL_HANDLER,
42333 ZEND_NULL_HANDLER,
42334 ZEND_NULL_HANDLER,
42335 ZEND_NULL_HANDLER,
42336 ZEND_NULL_HANDLER,
42337 ZEND_NULL_HANDLER,
42338 ZEND_NULL_HANDLER,
42339 ZEND_NULL_HANDLER,
42340 ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER,
42341 ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER,
42342 ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER,
42343 ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER,
42344 ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER,
42345 ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER,
42346 ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER,
42347 ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER,
42348 ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER,
42349 ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER,
42350 ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER,
42351 ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER,
42352 ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER,
42353 ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER,
42354 ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER,
42355 ZEND_NULL_HANDLER,
42356 ZEND_NULL_HANDLER,
42357 ZEND_NULL_HANDLER,
42358 ZEND_NULL_HANDLER,
42359 ZEND_NULL_HANDLER,
42360 ZEND_NULL_HANDLER,
42361 ZEND_NULL_HANDLER,
42362 ZEND_NULL_HANDLER,
42363 ZEND_NULL_HANDLER,
42364 ZEND_NULL_HANDLER,
42365 ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER,
42366 ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER,
42367 ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER,
42368 ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER,
42369 ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER,
42370 ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER,
42371 ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER,
42372 ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER,
42373 ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER,
42374 ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER,
42375 ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER,
42376 ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER,
42377 ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER,
42378 ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER,
42379 ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER,
42380 ZEND_NULL_HANDLER,
42381 ZEND_NULL_HANDLER,
42382 ZEND_NULL_HANDLER,
42383 ZEND_NULL_HANDLER,
42384 ZEND_NULL_HANDLER,
42385 ZEND_NULL_HANDLER,
42386 ZEND_NULL_HANDLER,
42387 ZEND_NULL_HANDLER,
42388 ZEND_NULL_HANDLER,
42389 ZEND_NULL_HANDLER,
42390 ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER,
42391 ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER,
42392 ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER,
42393 ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER,
42394 ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER,
42395 ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER,
42396 ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER,
42397 ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER,
42398 ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER,
42399 ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER,
42400 ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER,
42401 ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER,
42402 ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER,
42403 ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER,
42404 ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER,
42405 ZEND_NULL_HANDLER,
42406 ZEND_NULL_HANDLER,
42407 ZEND_NULL_HANDLER,
42408 ZEND_NULL_HANDLER,
42409 ZEND_NULL_HANDLER,
42410 ZEND_NULL_HANDLER,
42411 ZEND_NULL_HANDLER,
42412 ZEND_NULL_HANDLER,
42413 ZEND_NULL_HANDLER,
42414 ZEND_NULL_HANDLER,
42415 ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER,
42416 ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER,
42417 ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER,
42418 ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER,
42419 ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER,
42420 ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER,
42421 ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER,
42422 ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER,
42423 ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER,
42424 ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER,
42425 ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER,
42426 ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER,
42427 ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER,
42428 ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER,
42429 ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER,
42430 ZEND_NULL_HANDLER,
42431 ZEND_NULL_HANDLER,
42432 ZEND_NULL_HANDLER,
42433 ZEND_NULL_HANDLER,
42434 ZEND_NULL_HANDLER,
42435 ZEND_NULL_HANDLER,
42436 ZEND_NULL_HANDLER,
42437 ZEND_NULL_HANDLER,
42438 ZEND_NULL_HANDLER,
42439 ZEND_NULL_HANDLER,
42440 ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER,
42441 ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER,
42442 ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER,
42443 ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER,
42444 ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER,
42445 ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER,
42446 ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER,
42447 ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER,
42448 ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER,
42449 ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER,
42450 ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER,
42451 ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER,
42452 ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER,
42453 ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER,
42454 ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER,
42455 ZEND_NULL_HANDLER,
42456 ZEND_NULL_HANDLER,
42457 ZEND_NULL_HANDLER,
42458 ZEND_NULL_HANDLER,
42459 ZEND_NULL_HANDLER,
42460 ZEND_NULL_HANDLER,
42461 ZEND_NULL_HANDLER,
42462 ZEND_NULL_HANDLER,
42463 ZEND_NULL_HANDLER,
42464 ZEND_NULL_HANDLER,
42465 ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER,
42466 ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER,
42467 ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER,
42468 ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER,
42469 ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER,
42470 ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER,
42471 ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER,
42472 ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER,
42473 ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER,
42474 ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER,
42475 ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER,
42476 ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER,
42477 ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER,
42478 ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER,
42479 ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER,
42480 ZEND_NULL_HANDLER,
42481 ZEND_NULL_HANDLER,
42482 ZEND_NULL_HANDLER,
42483 ZEND_NULL_HANDLER,
42484 ZEND_NULL_HANDLER,
42485 ZEND_NULL_HANDLER,
42486 ZEND_NULL_HANDLER,
42487 ZEND_NULL_HANDLER,
42488 ZEND_NULL_HANDLER,
42489 ZEND_NULL_HANDLER,
42490 ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER,
42491 ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER,
42492 ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER,
42493 ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER,
42494 ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER,
42495 ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER,
42496 ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER,
42497 ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER,
42498 ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER,
42499 ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER,
42500 ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER,
42501 ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER,
42502 ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER,
42503 ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER,
42504 ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER,
42505 ZEND_NULL_HANDLER,
42506 ZEND_NULL_HANDLER,
42507 ZEND_NULL_HANDLER,
42508 ZEND_NULL_HANDLER,
42509 ZEND_NULL_HANDLER,
42510 ZEND_NULL_HANDLER,
42511 ZEND_NULL_HANDLER,
42512 ZEND_NULL_HANDLER,
42513 ZEND_NULL_HANDLER,
42514 ZEND_NULL_HANDLER,
42515 ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER,
42516 ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER,
42517 ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER,
42518 ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER,
42519 ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER,
42520 ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER,
42521 ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER,
42522 ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER,
42523 ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER,
42524 ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER,
42525 ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER,
42526 ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER,
42527 ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER,
42528 ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER,
42529 ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER,
42530 ZEND_NULL_HANDLER,
42531 ZEND_NULL_HANDLER,
42532 ZEND_NULL_HANDLER,
42533 ZEND_NULL_HANDLER,
42534 ZEND_NULL_HANDLER,
42535 ZEND_NULL_HANDLER,
42536 ZEND_NULL_HANDLER,
42537 ZEND_NULL_HANDLER,
42538 ZEND_NULL_HANDLER,
42539 ZEND_NULL_HANDLER,
42540 ZEND_PRE_INC_SPEC_VAR_HANDLER,
42541 ZEND_PRE_INC_SPEC_VAR_HANDLER,
42542 ZEND_PRE_INC_SPEC_VAR_HANDLER,
42543 ZEND_PRE_INC_SPEC_VAR_HANDLER,
42544 ZEND_PRE_INC_SPEC_VAR_HANDLER,
42545 ZEND_NULL_HANDLER,
42546 ZEND_NULL_HANDLER,
42547 ZEND_NULL_HANDLER,
42548 ZEND_NULL_HANDLER,
42549 ZEND_NULL_HANDLER,
42550 ZEND_PRE_INC_SPEC_CV_HANDLER,
42551 ZEND_PRE_INC_SPEC_CV_HANDLER,
42552 ZEND_PRE_INC_SPEC_CV_HANDLER,
42553 ZEND_PRE_INC_SPEC_CV_HANDLER,
42554 ZEND_PRE_INC_SPEC_CV_HANDLER,
42555 ZEND_NULL_HANDLER,
42556 ZEND_NULL_HANDLER,
42557 ZEND_NULL_HANDLER,
42558 ZEND_NULL_HANDLER,
42559 ZEND_NULL_HANDLER,
42560 ZEND_NULL_HANDLER,
42561 ZEND_NULL_HANDLER,
42562 ZEND_NULL_HANDLER,
42563 ZEND_NULL_HANDLER,
42564 ZEND_NULL_HANDLER,
42565 ZEND_PRE_DEC_SPEC_VAR_HANDLER,
42566 ZEND_PRE_DEC_SPEC_VAR_HANDLER,
42567 ZEND_PRE_DEC_SPEC_VAR_HANDLER,
42568 ZEND_PRE_DEC_SPEC_VAR_HANDLER,
42569 ZEND_PRE_DEC_SPEC_VAR_HANDLER,
42570 ZEND_NULL_HANDLER,
42571 ZEND_NULL_HANDLER,
42572 ZEND_NULL_HANDLER,
42573 ZEND_NULL_HANDLER,
42574 ZEND_NULL_HANDLER,
42575 ZEND_PRE_DEC_SPEC_CV_HANDLER,
42576 ZEND_PRE_DEC_SPEC_CV_HANDLER,
42577 ZEND_PRE_DEC_SPEC_CV_HANDLER,
42578 ZEND_PRE_DEC_SPEC_CV_HANDLER,
42579 ZEND_PRE_DEC_SPEC_CV_HANDLER,
42580 ZEND_NULL_HANDLER,
42581 ZEND_NULL_HANDLER,
42582 ZEND_NULL_HANDLER,
42583 ZEND_NULL_HANDLER,
42584 ZEND_NULL_HANDLER,
42585 ZEND_NULL_HANDLER,
42586 ZEND_NULL_HANDLER,
42587 ZEND_NULL_HANDLER,
42588 ZEND_NULL_HANDLER,
42589 ZEND_NULL_HANDLER,
42590 ZEND_POST_INC_SPEC_VAR_HANDLER,
42591 ZEND_POST_INC_SPEC_VAR_HANDLER,
42592 ZEND_POST_INC_SPEC_VAR_HANDLER,
42593 ZEND_POST_INC_SPEC_VAR_HANDLER,
42594 ZEND_POST_INC_SPEC_VAR_HANDLER,
42595 ZEND_NULL_HANDLER,
42596 ZEND_NULL_HANDLER,
42597 ZEND_NULL_HANDLER,
42598 ZEND_NULL_HANDLER,
42599 ZEND_NULL_HANDLER,
42600 ZEND_POST_INC_SPEC_CV_HANDLER,
42601 ZEND_POST_INC_SPEC_CV_HANDLER,
42602 ZEND_POST_INC_SPEC_CV_HANDLER,
42603 ZEND_POST_INC_SPEC_CV_HANDLER,
42604 ZEND_POST_INC_SPEC_CV_HANDLER,
42605 ZEND_NULL_HANDLER,
42606 ZEND_NULL_HANDLER,
42607 ZEND_NULL_HANDLER,
42608 ZEND_NULL_HANDLER,
42609 ZEND_NULL_HANDLER,
42610 ZEND_NULL_HANDLER,
42611 ZEND_NULL_HANDLER,
42612 ZEND_NULL_HANDLER,
42613 ZEND_NULL_HANDLER,
42614 ZEND_NULL_HANDLER,
42615 ZEND_POST_DEC_SPEC_VAR_HANDLER,
42616 ZEND_POST_DEC_SPEC_VAR_HANDLER,
42617 ZEND_POST_DEC_SPEC_VAR_HANDLER,
42618 ZEND_POST_DEC_SPEC_VAR_HANDLER,
42619 ZEND_POST_DEC_SPEC_VAR_HANDLER,
42620 ZEND_NULL_HANDLER,
42621 ZEND_NULL_HANDLER,
42622 ZEND_NULL_HANDLER,
42623 ZEND_NULL_HANDLER,
42624 ZEND_NULL_HANDLER,
42625 ZEND_POST_DEC_SPEC_CV_HANDLER,
42626 ZEND_POST_DEC_SPEC_CV_HANDLER,
42627 ZEND_POST_DEC_SPEC_CV_HANDLER,
42628 ZEND_POST_DEC_SPEC_CV_HANDLER,
42629 ZEND_POST_DEC_SPEC_CV_HANDLER,
42630 ZEND_NULL_HANDLER,
42631 ZEND_NULL_HANDLER,
42632 ZEND_NULL_HANDLER,
42633 ZEND_NULL_HANDLER,
42634 ZEND_NULL_HANDLER,
42635 ZEND_NULL_HANDLER,
42636 ZEND_NULL_HANDLER,
42637 ZEND_NULL_HANDLER,
42638 ZEND_NULL_HANDLER,
42639 ZEND_NULL_HANDLER,
42640 ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER,
42641 ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER,
42642 ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER,
42643 ZEND_NULL_HANDLER,
42644 ZEND_ASSIGN_SPEC_VAR_CV_HANDLER,
42645 ZEND_NULL_HANDLER,
42646 ZEND_NULL_HANDLER,
42647 ZEND_NULL_HANDLER,
42648 ZEND_NULL_HANDLER,
42649 ZEND_NULL_HANDLER,
42650 ZEND_ASSIGN_SPEC_CV_CONST_HANDLER,
42651 ZEND_ASSIGN_SPEC_CV_TMP_HANDLER,
42652 ZEND_ASSIGN_SPEC_CV_VAR_HANDLER,
42653 ZEND_NULL_HANDLER,
42654 ZEND_ASSIGN_SPEC_CV_CV_HANDLER,
42655 ZEND_NULL_HANDLER,
42656 ZEND_NULL_HANDLER,
42657 ZEND_NULL_HANDLER,
42658 ZEND_NULL_HANDLER,
42659 ZEND_NULL_HANDLER,
42660 ZEND_NULL_HANDLER,
42661 ZEND_NULL_HANDLER,
42662 ZEND_NULL_HANDLER,
42663 ZEND_NULL_HANDLER,
42664 ZEND_NULL_HANDLER,
42665 ZEND_NULL_HANDLER,
42666 ZEND_NULL_HANDLER,
42667 ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER,
42668 ZEND_NULL_HANDLER,
42669 ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER,
42670 ZEND_NULL_HANDLER,
42671 ZEND_NULL_HANDLER,
42672 ZEND_NULL_HANDLER,
42673 ZEND_NULL_HANDLER,
42674 ZEND_NULL_HANDLER,
42675 ZEND_NULL_HANDLER,
42676 ZEND_NULL_HANDLER,
42677 ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER,
42678 ZEND_NULL_HANDLER,
42679 ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER,
42680 ZEND_ECHO_SPEC_CONST_HANDLER,
42681 ZEND_ECHO_SPEC_CONST_HANDLER,
42682 ZEND_ECHO_SPEC_CONST_HANDLER,
42683 ZEND_ECHO_SPEC_CONST_HANDLER,
42684 ZEND_ECHO_SPEC_CONST_HANDLER,
42685 ZEND_ECHO_SPEC_TMP_HANDLER,
42686 ZEND_ECHO_SPEC_TMP_HANDLER,
42687 ZEND_ECHO_SPEC_TMP_HANDLER,
42688 ZEND_ECHO_SPEC_TMP_HANDLER,
42689 ZEND_ECHO_SPEC_TMP_HANDLER,
42690 ZEND_ECHO_SPEC_VAR_HANDLER,
42691 ZEND_ECHO_SPEC_VAR_HANDLER,
42692 ZEND_ECHO_SPEC_VAR_HANDLER,
42693 ZEND_ECHO_SPEC_VAR_HANDLER,
42694 ZEND_ECHO_SPEC_VAR_HANDLER,
42695 ZEND_NULL_HANDLER,
42696 ZEND_NULL_HANDLER,
42697 ZEND_NULL_HANDLER,
42698 ZEND_NULL_HANDLER,
42699 ZEND_NULL_HANDLER,
42700 ZEND_ECHO_SPEC_CV_HANDLER,
42701 ZEND_ECHO_SPEC_CV_HANDLER,
42702 ZEND_ECHO_SPEC_CV_HANDLER,
42703 ZEND_ECHO_SPEC_CV_HANDLER,
42704 ZEND_ECHO_SPEC_CV_HANDLER,
42705 ZEND_PRINT_SPEC_CONST_HANDLER,
42706 ZEND_PRINT_SPEC_CONST_HANDLER,
42707 ZEND_PRINT_SPEC_CONST_HANDLER,
42708 ZEND_PRINT_SPEC_CONST_HANDLER,
42709 ZEND_PRINT_SPEC_CONST_HANDLER,
42710 ZEND_PRINT_SPEC_TMP_HANDLER,
42711 ZEND_PRINT_SPEC_TMP_HANDLER,
42712 ZEND_PRINT_SPEC_TMP_HANDLER,
42713 ZEND_PRINT_SPEC_TMP_HANDLER,
42714 ZEND_PRINT_SPEC_TMP_HANDLER,
42715 ZEND_PRINT_SPEC_VAR_HANDLER,
42716 ZEND_PRINT_SPEC_VAR_HANDLER,
42717 ZEND_PRINT_SPEC_VAR_HANDLER,
42718 ZEND_PRINT_SPEC_VAR_HANDLER,
42719 ZEND_PRINT_SPEC_VAR_HANDLER,
42720 ZEND_NULL_HANDLER,
42721 ZEND_NULL_HANDLER,
42722 ZEND_NULL_HANDLER,
42723 ZEND_NULL_HANDLER,
42724 ZEND_NULL_HANDLER,
42725 ZEND_PRINT_SPEC_CV_HANDLER,
42726 ZEND_PRINT_SPEC_CV_HANDLER,
42727 ZEND_PRINT_SPEC_CV_HANDLER,
42728 ZEND_PRINT_SPEC_CV_HANDLER,
42729 ZEND_PRINT_SPEC_CV_HANDLER,
42730 ZEND_JMP_SPEC_HANDLER,
42731 ZEND_JMP_SPEC_HANDLER,
42732 ZEND_JMP_SPEC_HANDLER,
42733 ZEND_JMP_SPEC_HANDLER,
42734 ZEND_JMP_SPEC_HANDLER,
42735 ZEND_JMP_SPEC_HANDLER,
42736 ZEND_JMP_SPEC_HANDLER,
42737 ZEND_JMP_SPEC_HANDLER,
42738 ZEND_JMP_SPEC_HANDLER,
42739 ZEND_JMP_SPEC_HANDLER,
42740 ZEND_JMP_SPEC_HANDLER,
42741 ZEND_JMP_SPEC_HANDLER,
42742 ZEND_JMP_SPEC_HANDLER,
42743 ZEND_JMP_SPEC_HANDLER,
42744 ZEND_JMP_SPEC_HANDLER,
42745 ZEND_JMP_SPEC_HANDLER,
42746 ZEND_JMP_SPEC_HANDLER,
42747 ZEND_JMP_SPEC_HANDLER,
42748 ZEND_JMP_SPEC_HANDLER,
42749 ZEND_JMP_SPEC_HANDLER,
42750 ZEND_JMP_SPEC_HANDLER,
42751 ZEND_JMP_SPEC_HANDLER,
42752 ZEND_JMP_SPEC_HANDLER,
42753 ZEND_JMP_SPEC_HANDLER,
42754 ZEND_JMP_SPEC_HANDLER,
42755 ZEND_JMPZ_SPEC_CONST_HANDLER,
42756 ZEND_JMPZ_SPEC_CONST_HANDLER,
42757 ZEND_JMPZ_SPEC_CONST_HANDLER,
42758 ZEND_JMPZ_SPEC_CONST_HANDLER,
42759 ZEND_JMPZ_SPEC_CONST_HANDLER,
42760 ZEND_JMPZ_SPEC_TMP_HANDLER,
42761 ZEND_JMPZ_SPEC_TMP_HANDLER,
42762 ZEND_JMPZ_SPEC_TMP_HANDLER,
42763 ZEND_JMPZ_SPEC_TMP_HANDLER,
42764 ZEND_JMPZ_SPEC_TMP_HANDLER,
42765 ZEND_JMPZ_SPEC_VAR_HANDLER,
42766 ZEND_JMPZ_SPEC_VAR_HANDLER,
42767 ZEND_JMPZ_SPEC_VAR_HANDLER,
42768 ZEND_JMPZ_SPEC_VAR_HANDLER,
42769 ZEND_JMPZ_SPEC_VAR_HANDLER,
42770 ZEND_NULL_HANDLER,
42771 ZEND_NULL_HANDLER,
42772 ZEND_NULL_HANDLER,
42773 ZEND_NULL_HANDLER,
42774 ZEND_NULL_HANDLER,
42775 ZEND_JMPZ_SPEC_CV_HANDLER,
42776 ZEND_JMPZ_SPEC_CV_HANDLER,
42777 ZEND_JMPZ_SPEC_CV_HANDLER,
42778 ZEND_JMPZ_SPEC_CV_HANDLER,
42779 ZEND_JMPZ_SPEC_CV_HANDLER,
42780 ZEND_JMPNZ_SPEC_CONST_HANDLER,
42781 ZEND_JMPNZ_SPEC_CONST_HANDLER,
42782 ZEND_JMPNZ_SPEC_CONST_HANDLER,
42783 ZEND_JMPNZ_SPEC_CONST_HANDLER,
42784 ZEND_JMPNZ_SPEC_CONST_HANDLER,
42785 ZEND_JMPNZ_SPEC_TMP_HANDLER,
42786 ZEND_JMPNZ_SPEC_TMP_HANDLER,
42787 ZEND_JMPNZ_SPEC_TMP_HANDLER,
42788 ZEND_JMPNZ_SPEC_TMP_HANDLER,
42789 ZEND_JMPNZ_SPEC_TMP_HANDLER,
42790 ZEND_JMPNZ_SPEC_VAR_HANDLER,
42791 ZEND_JMPNZ_SPEC_VAR_HANDLER,
42792 ZEND_JMPNZ_SPEC_VAR_HANDLER,
42793 ZEND_JMPNZ_SPEC_VAR_HANDLER,
42794 ZEND_JMPNZ_SPEC_VAR_HANDLER,
42795 ZEND_NULL_HANDLER,
42796 ZEND_NULL_HANDLER,
42797 ZEND_NULL_HANDLER,
42798 ZEND_NULL_HANDLER,
42799 ZEND_NULL_HANDLER,
42800 ZEND_JMPNZ_SPEC_CV_HANDLER,
42801 ZEND_JMPNZ_SPEC_CV_HANDLER,
42802 ZEND_JMPNZ_SPEC_CV_HANDLER,
42803 ZEND_JMPNZ_SPEC_CV_HANDLER,
42804 ZEND_JMPNZ_SPEC_CV_HANDLER,
42805 ZEND_JMPZNZ_SPEC_CONST_HANDLER,
42806 ZEND_JMPZNZ_SPEC_CONST_HANDLER,
42807 ZEND_JMPZNZ_SPEC_CONST_HANDLER,
42808 ZEND_JMPZNZ_SPEC_CONST_HANDLER,
42809 ZEND_JMPZNZ_SPEC_CONST_HANDLER,
42810 ZEND_JMPZNZ_SPEC_TMP_HANDLER,
42811 ZEND_JMPZNZ_SPEC_TMP_HANDLER,
42812 ZEND_JMPZNZ_SPEC_TMP_HANDLER,
42813 ZEND_JMPZNZ_SPEC_TMP_HANDLER,
42814 ZEND_JMPZNZ_SPEC_TMP_HANDLER,
42815 ZEND_JMPZNZ_SPEC_VAR_HANDLER,
42816 ZEND_JMPZNZ_SPEC_VAR_HANDLER,
42817 ZEND_JMPZNZ_SPEC_VAR_HANDLER,
42818 ZEND_JMPZNZ_SPEC_VAR_HANDLER,
42819 ZEND_JMPZNZ_SPEC_VAR_HANDLER,
42820 ZEND_NULL_HANDLER,
42821 ZEND_NULL_HANDLER,
42822 ZEND_NULL_HANDLER,
42823 ZEND_NULL_HANDLER,
42824 ZEND_NULL_HANDLER,
42825 ZEND_JMPZNZ_SPEC_CV_HANDLER,
42826 ZEND_JMPZNZ_SPEC_CV_HANDLER,
42827 ZEND_JMPZNZ_SPEC_CV_HANDLER,
42828 ZEND_JMPZNZ_SPEC_CV_HANDLER,
42829 ZEND_JMPZNZ_SPEC_CV_HANDLER,
42830 ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
42831 ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
42832 ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
42833 ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
42834 ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
42835 ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
42836 ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
42837 ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
42838 ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
42839 ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
42840 ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
42841 ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
42842 ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
42843 ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
42844 ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
42845 ZEND_NULL_HANDLER,
42846 ZEND_NULL_HANDLER,
42847 ZEND_NULL_HANDLER,
42848 ZEND_NULL_HANDLER,
42849 ZEND_NULL_HANDLER,
42850 ZEND_JMPZ_EX_SPEC_CV_HANDLER,
42851 ZEND_JMPZ_EX_SPEC_CV_HANDLER,
42852 ZEND_JMPZ_EX_SPEC_CV_HANDLER,
42853 ZEND_JMPZ_EX_SPEC_CV_HANDLER,
42854 ZEND_JMPZ_EX_SPEC_CV_HANDLER,
42855 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
42856 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
42857 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
42858 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
42859 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
42860 ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
42861 ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
42862 ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
42863 ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
42864 ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
42865 ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
42866 ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
42867 ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
42868 ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
42869 ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
42870 ZEND_NULL_HANDLER,
42871 ZEND_NULL_HANDLER,
42872 ZEND_NULL_HANDLER,
42873 ZEND_NULL_HANDLER,
42874 ZEND_NULL_HANDLER,
42875 ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
42876 ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
42877 ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
42878 ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
42879 ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
42880 ZEND_CASE_SPEC_CONST_CONST_HANDLER,
42881 ZEND_CASE_SPEC_CONST_TMP_HANDLER,
42882 ZEND_CASE_SPEC_CONST_VAR_HANDLER,
42883 ZEND_NULL_HANDLER,
42884 ZEND_CASE_SPEC_CONST_CV_HANDLER,
42885 ZEND_CASE_SPEC_TMP_CONST_HANDLER,
42886 ZEND_CASE_SPEC_TMP_TMP_HANDLER,
42887 ZEND_CASE_SPEC_TMP_VAR_HANDLER,
42888 ZEND_NULL_HANDLER,
42889 ZEND_CASE_SPEC_TMP_CV_HANDLER,
42890 ZEND_CASE_SPEC_VAR_CONST_HANDLER,
42891 ZEND_CASE_SPEC_VAR_TMP_HANDLER,
42892 ZEND_CASE_SPEC_VAR_VAR_HANDLER,
42893 ZEND_NULL_HANDLER,
42894 ZEND_CASE_SPEC_VAR_CV_HANDLER,
42895 ZEND_NULL_HANDLER,
42896 ZEND_NULL_HANDLER,
42897 ZEND_NULL_HANDLER,
42898 ZEND_NULL_HANDLER,
42899 ZEND_NULL_HANDLER,
42900 ZEND_CASE_SPEC_CV_CONST_HANDLER,
42901 ZEND_CASE_SPEC_CV_TMP_HANDLER,
42902 ZEND_CASE_SPEC_CV_VAR_HANDLER,
42903 ZEND_NULL_HANDLER,
42904 ZEND_CASE_SPEC_CV_CV_HANDLER,
42905 ZEND_NULL_HANDLER,
42906 ZEND_NULL_HANDLER,
42907 ZEND_NULL_HANDLER,
42908 ZEND_NULL_HANDLER,
42909 ZEND_NULL_HANDLER,
42910 ZEND_NULL_HANDLER,
42911 ZEND_NULL_HANDLER,
42912 ZEND_NULL_HANDLER,
42913 ZEND_NULL_HANDLER,
42914 ZEND_NULL_HANDLER,
42915 ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
42916 ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
42917 ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
42918 ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
42919 ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
42920 ZEND_NULL_HANDLER,
42921 ZEND_NULL_HANDLER,
42922 ZEND_NULL_HANDLER,
42923 ZEND_NULL_HANDLER,
42924 ZEND_NULL_HANDLER,
42925 ZEND_NULL_HANDLER,
42926 ZEND_NULL_HANDLER,
42927 ZEND_NULL_HANDLER,
42928 ZEND_NULL_HANDLER,
42929 ZEND_NULL_HANDLER,
42930 ZEND_BRK_SPEC_CONST_HANDLER,
42931 ZEND_NULL_HANDLER,
42932 ZEND_NULL_HANDLER,
42933 ZEND_NULL_HANDLER,
42934 ZEND_NULL_HANDLER,
42935 ZEND_BRK_SPEC_CONST_HANDLER,
42936 ZEND_NULL_HANDLER,
42937 ZEND_NULL_HANDLER,
42938 ZEND_NULL_HANDLER,
42939 ZEND_NULL_HANDLER,
42940 ZEND_BRK_SPEC_CONST_HANDLER,
42941 ZEND_NULL_HANDLER,
42942 ZEND_NULL_HANDLER,
42943 ZEND_NULL_HANDLER,
42944 ZEND_NULL_HANDLER,
42945 ZEND_BRK_SPEC_CONST_HANDLER,
42946 ZEND_NULL_HANDLER,
42947 ZEND_NULL_HANDLER,
42948 ZEND_NULL_HANDLER,
42949 ZEND_NULL_HANDLER,
42950 ZEND_BRK_SPEC_CONST_HANDLER,
42951 ZEND_NULL_HANDLER,
42952 ZEND_NULL_HANDLER,
42953 ZEND_NULL_HANDLER,
42954 ZEND_NULL_HANDLER,
42955 ZEND_CONT_SPEC_CONST_HANDLER,
42956 ZEND_NULL_HANDLER,
42957 ZEND_NULL_HANDLER,
42958 ZEND_NULL_HANDLER,
42959 ZEND_NULL_HANDLER,
42960 ZEND_CONT_SPEC_CONST_HANDLER,
42961 ZEND_NULL_HANDLER,
42962 ZEND_NULL_HANDLER,
42963 ZEND_NULL_HANDLER,
42964 ZEND_NULL_HANDLER,
42965 ZEND_CONT_SPEC_CONST_HANDLER,
42966 ZEND_NULL_HANDLER,
42967 ZEND_NULL_HANDLER,
42968 ZEND_NULL_HANDLER,
42969 ZEND_NULL_HANDLER,
42970 ZEND_CONT_SPEC_CONST_HANDLER,
42971 ZEND_NULL_HANDLER,
42972 ZEND_NULL_HANDLER,
42973 ZEND_NULL_HANDLER,
42974 ZEND_NULL_HANDLER,
42975 ZEND_CONT_SPEC_CONST_HANDLER,
42976 ZEND_NULL_HANDLER,
42977 ZEND_NULL_HANDLER,
42978 ZEND_NULL_HANDLER,
42979 ZEND_NULL_HANDLER,
42980 ZEND_BOOL_SPEC_CONST_HANDLER,
42981 ZEND_BOOL_SPEC_CONST_HANDLER,
42982 ZEND_BOOL_SPEC_CONST_HANDLER,
42983 ZEND_BOOL_SPEC_CONST_HANDLER,
42984 ZEND_BOOL_SPEC_CONST_HANDLER,
42985 ZEND_BOOL_SPEC_TMP_HANDLER,
42986 ZEND_BOOL_SPEC_TMP_HANDLER,
42987 ZEND_BOOL_SPEC_TMP_HANDLER,
42988 ZEND_BOOL_SPEC_TMP_HANDLER,
42989 ZEND_BOOL_SPEC_TMP_HANDLER,
42990 ZEND_BOOL_SPEC_VAR_HANDLER,
42991 ZEND_BOOL_SPEC_VAR_HANDLER,
42992 ZEND_BOOL_SPEC_VAR_HANDLER,
42993 ZEND_BOOL_SPEC_VAR_HANDLER,
42994 ZEND_BOOL_SPEC_VAR_HANDLER,
42995 ZEND_NULL_HANDLER,
42996 ZEND_NULL_HANDLER,
42997 ZEND_NULL_HANDLER,
42998 ZEND_NULL_HANDLER,
42999 ZEND_NULL_HANDLER,
43000 ZEND_BOOL_SPEC_CV_HANDLER,
43001 ZEND_BOOL_SPEC_CV_HANDLER,
43002 ZEND_BOOL_SPEC_CV_HANDLER,
43003 ZEND_BOOL_SPEC_CV_HANDLER,
43004 ZEND_BOOL_SPEC_CV_HANDLER,
43005 ZEND_INIT_STRING_SPEC_HANDLER,
43006 ZEND_INIT_STRING_SPEC_HANDLER,
43007 ZEND_INIT_STRING_SPEC_HANDLER,
43008 ZEND_INIT_STRING_SPEC_HANDLER,
43009 ZEND_INIT_STRING_SPEC_HANDLER,
43010 ZEND_INIT_STRING_SPEC_HANDLER,
43011 ZEND_INIT_STRING_SPEC_HANDLER,
43012 ZEND_INIT_STRING_SPEC_HANDLER,
43013 ZEND_INIT_STRING_SPEC_HANDLER,
43014 ZEND_INIT_STRING_SPEC_HANDLER,
43015 ZEND_INIT_STRING_SPEC_HANDLER,
43016 ZEND_INIT_STRING_SPEC_HANDLER,
43017 ZEND_INIT_STRING_SPEC_HANDLER,
43018 ZEND_INIT_STRING_SPEC_HANDLER,
43019 ZEND_INIT_STRING_SPEC_HANDLER,
43020 ZEND_INIT_STRING_SPEC_HANDLER,
43021 ZEND_INIT_STRING_SPEC_HANDLER,
43022 ZEND_INIT_STRING_SPEC_HANDLER,
43023 ZEND_INIT_STRING_SPEC_HANDLER,
43024 ZEND_INIT_STRING_SPEC_HANDLER,
43025 ZEND_INIT_STRING_SPEC_HANDLER,
43026 ZEND_INIT_STRING_SPEC_HANDLER,
43027 ZEND_INIT_STRING_SPEC_HANDLER,
43028 ZEND_INIT_STRING_SPEC_HANDLER,
43029 ZEND_INIT_STRING_SPEC_HANDLER,
43030 ZEND_NULL_HANDLER,
43031 ZEND_NULL_HANDLER,
43032 ZEND_NULL_HANDLER,
43033 ZEND_NULL_HANDLER,
43034 ZEND_NULL_HANDLER,
43035 ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER,
43036 ZEND_NULL_HANDLER,
43037 ZEND_NULL_HANDLER,
43038 ZEND_NULL_HANDLER,
43039 ZEND_NULL_HANDLER,
43040 ZEND_NULL_HANDLER,
43041 ZEND_NULL_HANDLER,
43042 ZEND_NULL_HANDLER,
43043 ZEND_NULL_HANDLER,
43044 ZEND_NULL_HANDLER,
43045 ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER,
43046 ZEND_NULL_HANDLER,
43047 ZEND_NULL_HANDLER,
43048 ZEND_NULL_HANDLER,
43049 ZEND_NULL_HANDLER,
43050 ZEND_NULL_HANDLER,
43051 ZEND_NULL_HANDLER,
43052 ZEND_NULL_HANDLER,
43053 ZEND_NULL_HANDLER,
43054 ZEND_NULL_HANDLER,
43055 ZEND_NULL_HANDLER,
43056 ZEND_NULL_HANDLER,
43057 ZEND_NULL_HANDLER,
43058 ZEND_NULL_HANDLER,
43059 ZEND_NULL_HANDLER,
43060 ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER,
43061 ZEND_NULL_HANDLER,
43062 ZEND_NULL_HANDLER,
43063 ZEND_NULL_HANDLER,
43064 ZEND_NULL_HANDLER,
43065 ZEND_NULL_HANDLER,
43066 ZEND_NULL_HANDLER,
43067 ZEND_NULL_HANDLER,
43068 ZEND_NULL_HANDLER,
43069 ZEND_NULL_HANDLER,
43070 ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER,
43071 ZEND_NULL_HANDLER,
43072 ZEND_NULL_HANDLER,
43073 ZEND_NULL_HANDLER,
43074 ZEND_NULL_HANDLER,
43075 ZEND_NULL_HANDLER,
43076 ZEND_NULL_HANDLER,
43077 ZEND_NULL_HANDLER,
43078 ZEND_NULL_HANDLER,
43079 ZEND_NULL_HANDLER,
43080 ZEND_NULL_HANDLER,
43081 ZEND_NULL_HANDLER,
43082 ZEND_NULL_HANDLER,
43083 ZEND_NULL_HANDLER,
43084 ZEND_NULL_HANDLER,
43085 ZEND_NULL_HANDLER,
43086 ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER,
43087 ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER,
43088 ZEND_NULL_HANDLER,
43089 ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER,
43090 ZEND_NULL_HANDLER,
43091 ZEND_NULL_HANDLER,
43092 ZEND_NULL_HANDLER,
43093 ZEND_NULL_HANDLER,
43094 ZEND_NULL_HANDLER,
43095 ZEND_NULL_HANDLER,
43096 ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER,
43097 ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER,
43098 ZEND_NULL_HANDLER,
43099 ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER,
43100 ZEND_NULL_HANDLER,
43101 ZEND_NULL_HANDLER,
43102 ZEND_NULL_HANDLER,
43103 ZEND_NULL_HANDLER,
43104 ZEND_NULL_HANDLER,
43105 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43106 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43107 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43108 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43109 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43110 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43111 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43112 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43113 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43114 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43115 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43116 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43117 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43118 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43119 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43120 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43121 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43122 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43123 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43124 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43125 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43126 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43127 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43128 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43129 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
43130 ZEND_NULL_HANDLER,
43131 ZEND_NULL_HANDLER,
43132 ZEND_NULL_HANDLER,
43133 ZEND_NULL_HANDLER,
43134 ZEND_NULL_HANDLER,
43135 ZEND_END_SILENCE_SPEC_TMP_HANDLER,
43136 ZEND_END_SILENCE_SPEC_TMP_HANDLER,
43137 ZEND_END_SILENCE_SPEC_TMP_HANDLER,
43138 ZEND_END_SILENCE_SPEC_TMP_HANDLER,
43139 ZEND_END_SILENCE_SPEC_TMP_HANDLER,
43140 ZEND_NULL_HANDLER,
43141 ZEND_NULL_HANDLER,
43142 ZEND_NULL_HANDLER,
43143 ZEND_NULL_HANDLER,
43144 ZEND_NULL_HANDLER,
43145 ZEND_NULL_HANDLER,
43146 ZEND_NULL_HANDLER,
43147 ZEND_NULL_HANDLER,
43148 ZEND_NULL_HANDLER,
43149 ZEND_NULL_HANDLER,
43150 ZEND_NULL_HANDLER,
43151 ZEND_NULL_HANDLER,
43152 ZEND_NULL_HANDLER,
43153 ZEND_NULL_HANDLER,
43154 ZEND_NULL_HANDLER,
43155 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43156 ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
43157 ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
43158 ZEND_NULL_HANDLER,
43159 ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
43160 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43161 ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
43162 ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
43163 ZEND_NULL_HANDLER,
43164 ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
43165 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43166 ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
43167 ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
43168 ZEND_NULL_HANDLER,
43169 ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
43170 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43171 ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
43172 ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
43173 ZEND_NULL_HANDLER,
43174 ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
43175 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43176 ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
43177 ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
43178 ZEND_NULL_HANDLER,
43179 ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
43180 ZEND_DO_FCALL_SPEC_CONST_HANDLER,
43181 ZEND_DO_FCALL_SPEC_CONST_HANDLER,
43182 ZEND_DO_FCALL_SPEC_CONST_HANDLER,
43183 ZEND_DO_FCALL_SPEC_CONST_HANDLER,
43184 ZEND_DO_FCALL_SPEC_CONST_HANDLER,
43185 ZEND_NULL_HANDLER,
43186 ZEND_NULL_HANDLER,
43187 ZEND_NULL_HANDLER,
43188 ZEND_NULL_HANDLER,
43189 ZEND_NULL_HANDLER,
43190 ZEND_NULL_HANDLER,
43191 ZEND_NULL_HANDLER,
43192 ZEND_NULL_HANDLER,
43193 ZEND_NULL_HANDLER,
43194 ZEND_NULL_HANDLER,
43195 ZEND_NULL_HANDLER,
43196 ZEND_NULL_HANDLER,
43197 ZEND_NULL_HANDLER,
43198 ZEND_NULL_HANDLER,
43199 ZEND_NULL_HANDLER,
43200 ZEND_NULL_HANDLER,
43201 ZEND_NULL_HANDLER,
43202 ZEND_NULL_HANDLER,
43203 ZEND_NULL_HANDLER,
43204 ZEND_NULL_HANDLER,
43205 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43206 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43207 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43208 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43209 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43210 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43211 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43212 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43213 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43214 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43215 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43216 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43217 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43218 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43219 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43220 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43221 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43222 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43223 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43224 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43225 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43226 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43227 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43228 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43229 ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
43230 ZEND_RETURN_SPEC_CONST_HANDLER,
43231 ZEND_RETURN_SPEC_CONST_HANDLER,
43232 ZEND_RETURN_SPEC_CONST_HANDLER,
43233 ZEND_RETURN_SPEC_CONST_HANDLER,
43234 ZEND_RETURN_SPEC_CONST_HANDLER,
43235 ZEND_RETURN_SPEC_TMP_HANDLER,
43236 ZEND_RETURN_SPEC_TMP_HANDLER,
43237 ZEND_RETURN_SPEC_TMP_HANDLER,
43238 ZEND_RETURN_SPEC_TMP_HANDLER,
43239 ZEND_RETURN_SPEC_TMP_HANDLER,
43240 ZEND_RETURN_SPEC_VAR_HANDLER,
43241 ZEND_RETURN_SPEC_VAR_HANDLER,
43242 ZEND_RETURN_SPEC_VAR_HANDLER,
43243 ZEND_RETURN_SPEC_VAR_HANDLER,
43244 ZEND_RETURN_SPEC_VAR_HANDLER,
43245 ZEND_NULL_HANDLER,
43246 ZEND_NULL_HANDLER,
43247 ZEND_NULL_HANDLER,
43248 ZEND_NULL_HANDLER,
43249 ZEND_NULL_HANDLER,
43250 ZEND_RETURN_SPEC_CV_HANDLER,
43251 ZEND_RETURN_SPEC_CV_HANDLER,
43252 ZEND_RETURN_SPEC_CV_HANDLER,
43253 ZEND_RETURN_SPEC_CV_HANDLER,
43254 ZEND_RETURN_SPEC_CV_HANDLER,
43255 ZEND_RECV_SPEC_HANDLER,
43256 ZEND_RECV_SPEC_HANDLER,
43257 ZEND_RECV_SPEC_HANDLER,
43258 ZEND_RECV_SPEC_HANDLER,
43259 ZEND_RECV_SPEC_HANDLER,
43260 ZEND_RECV_SPEC_HANDLER,
43261 ZEND_RECV_SPEC_HANDLER,
43262 ZEND_RECV_SPEC_HANDLER,
43263 ZEND_RECV_SPEC_HANDLER,
43264 ZEND_RECV_SPEC_HANDLER,
43265 ZEND_RECV_SPEC_HANDLER,
43266 ZEND_RECV_SPEC_HANDLER,
43267 ZEND_RECV_SPEC_HANDLER,
43268 ZEND_RECV_SPEC_HANDLER,
43269 ZEND_RECV_SPEC_HANDLER,
43270 ZEND_RECV_SPEC_HANDLER,
43271 ZEND_RECV_SPEC_HANDLER,
43272 ZEND_RECV_SPEC_HANDLER,
43273 ZEND_RECV_SPEC_HANDLER,
43274 ZEND_RECV_SPEC_HANDLER,
43275 ZEND_RECV_SPEC_HANDLER,
43276 ZEND_RECV_SPEC_HANDLER,
43277 ZEND_RECV_SPEC_HANDLER,
43278 ZEND_RECV_SPEC_HANDLER,
43279 ZEND_RECV_SPEC_HANDLER,
43280 ZEND_RECV_INIT_SPEC_CONST_HANDLER,
43281 ZEND_NULL_HANDLER,
43282 ZEND_NULL_HANDLER,
43283 ZEND_NULL_HANDLER,
43284 ZEND_NULL_HANDLER,
43285 ZEND_RECV_INIT_SPEC_CONST_HANDLER,
43286 ZEND_NULL_HANDLER,
43287 ZEND_NULL_HANDLER,
43288 ZEND_NULL_HANDLER,
43289 ZEND_NULL_HANDLER,
43290 ZEND_RECV_INIT_SPEC_CONST_HANDLER,
43291 ZEND_NULL_HANDLER,
43292 ZEND_NULL_HANDLER,
43293 ZEND_NULL_HANDLER,
43294 ZEND_NULL_HANDLER,
43295 ZEND_RECV_INIT_SPEC_CONST_HANDLER,
43296 ZEND_NULL_HANDLER,
43297 ZEND_NULL_HANDLER,
43298 ZEND_NULL_HANDLER,
43299 ZEND_NULL_HANDLER,
43300 ZEND_RECV_INIT_SPEC_CONST_HANDLER,
43301 ZEND_NULL_HANDLER,
43302 ZEND_NULL_HANDLER,
43303 ZEND_NULL_HANDLER,
43304 ZEND_NULL_HANDLER,
43305 ZEND_SEND_VAL_SPEC_CONST_HANDLER,
43306 ZEND_SEND_VAL_SPEC_CONST_HANDLER,
43307 ZEND_SEND_VAL_SPEC_CONST_HANDLER,
43308 ZEND_SEND_VAL_SPEC_CONST_HANDLER,
43309 ZEND_SEND_VAL_SPEC_CONST_HANDLER,
43310 ZEND_SEND_VAL_SPEC_TMP_HANDLER,
43311 ZEND_SEND_VAL_SPEC_TMP_HANDLER,
43312 ZEND_SEND_VAL_SPEC_TMP_HANDLER,
43313 ZEND_SEND_VAL_SPEC_TMP_HANDLER,
43314 ZEND_SEND_VAL_SPEC_TMP_HANDLER,
43315 ZEND_NULL_HANDLER,
43316 ZEND_NULL_HANDLER,
43317 ZEND_NULL_HANDLER,
43318 ZEND_NULL_HANDLER,
43319 ZEND_NULL_HANDLER,
43320 ZEND_NULL_HANDLER,
43321 ZEND_NULL_HANDLER,
43322 ZEND_NULL_HANDLER,
43323 ZEND_NULL_HANDLER,
43324 ZEND_NULL_HANDLER,
43325 ZEND_NULL_HANDLER,
43326 ZEND_NULL_HANDLER,
43327 ZEND_NULL_HANDLER,
43328 ZEND_NULL_HANDLER,
43329 ZEND_NULL_HANDLER,
43330 ZEND_NULL_HANDLER,
43331 ZEND_NULL_HANDLER,
43332 ZEND_NULL_HANDLER,
43333 ZEND_NULL_HANDLER,
43334 ZEND_NULL_HANDLER,
43335 ZEND_NULL_HANDLER,
43336 ZEND_NULL_HANDLER,
43337 ZEND_NULL_HANDLER,
43338 ZEND_NULL_HANDLER,
43339 ZEND_NULL_HANDLER,
43340 ZEND_SEND_VAR_SPEC_VAR_HANDLER,
43341 ZEND_SEND_VAR_SPEC_VAR_HANDLER,
43342 ZEND_SEND_VAR_SPEC_VAR_HANDLER,
43343 ZEND_SEND_VAR_SPEC_VAR_HANDLER,
43344 ZEND_SEND_VAR_SPEC_VAR_HANDLER,
43345 ZEND_NULL_HANDLER,
43346 ZEND_NULL_HANDLER,
43347 ZEND_NULL_HANDLER,
43348 ZEND_NULL_HANDLER,
43349 ZEND_NULL_HANDLER,
43350 ZEND_SEND_VAR_SPEC_CV_HANDLER,
43351 ZEND_SEND_VAR_SPEC_CV_HANDLER,
43352 ZEND_SEND_VAR_SPEC_CV_HANDLER,
43353 ZEND_SEND_VAR_SPEC_CV_HANDLER,
43354 ZEND_SEND_VAR_SPEC_CV_HANDLER,
43355 ZEND_NULL_HANDLER,
43356 ZEND_NULL_HANDLER,
43357 ZEND_NULL_HANDLER,
43358 ZEND_NULL_HANDLER,
43359 ZEND_NULL_HANDLER,
43360 ZEND_NULL_HANDLER,
43361 ZEND_NULL_HANDLER,
43362 ZEND_NULL_HANDLER,
43363 ZEND_NULL_HANDLER,
43364 ZEND_NULL_HANDLER,
43365 ZEND_SEND_REF_SPEC_VAR_HANDLER,
43366 ZEND_SEND_REF_SPEC_VAR_HANDLER,
43367 ZEND_SEND_REF_SPEC_VAR_HANDLER,
43368 ZEND_SEND_REF_SPEC_VAR_HANDLER,
43369 ZEND_SEND_REF_SPEC_VAR_HANDLER,
43370 ZEND_NULL_HANDLER,
43371 ZEND_NULL_HANDLER,
43372 ZEND_NULL_HANDLER,
43373 ZEND_NULL_HANDLER,
43374 ZEND_NULL_HANDLER,
43375 ZEND_SEND_REF_SPEC_CV_HANDLER,
43376 ZEND_SEND_REF_SPEC_CV_HANDLER,
43377 ZEND_SEND_REF_SPEC_CV_HANDLER,
43378 ZEND_SEND_REF_SPEC_CV_HANDLER,
43379 ZEND_SEND_REF_SPEC_CV_HANDLER,
43380 ZEND_NEW_SPEC_HANDLER,
43381 ZEND_NEW_SPEC_HANDLER,
43382 ZEND_NEW_SPEC_HANDLER,
43383 ZEND_NEW_SPEC_HANDLER,
43384 ZEND_NEW_SPEC_HANDLER,
43385 ZEND_NEW_SPEC_HANDLER,
43386 ZEND_NEW_SPEC_HANDLER,
43387 ZEND_NEW_SPEC_HANDLER,
43388 ZEND_NEW_SPEC_HANDLER,
43389 ZEND_NEW_SPEC_HANDLER,
43390 ZEND_NEW_SPEC_HANDLER,
43391 ZEND_NEW_SPEC_HANDLER,
43392 ZEND_NEW_SPEC_HANDLER,
43393 ZEND_NEW_SPEC_HANDLER,
43394 ZEND_NEW_SPEC_HANDLER,
43395 ZEND_NEW_SPEC_HANDLER,
43396 ZEND_NEW_SPEC_HANDLER,
43397 ZEND_NEW_SPEC_HANDLER,
43398 ZEND_NEW_SPEC_HANDLER,
43399 ZEND_NEW_SPEC_HANDLER,
43400 ZEND_NEW_SPEC_HANDLER,
43401 ZEND_NEW_SPEC_HANDLER,
43402 ZEND_NEW_SPEC_HANDLER,
43403 ZEND_NEW_SPEC_HANDLER,
43404 ZEND_NEW_SPEC_HANDLER,
43405 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43406 ZEND_NULL_HANDLER,
43407 ZEND_NULL_HANDLER,
43408 ZEND_NULL_HANDLER,
43409 ZEND_NULL_HANDLER,
43410 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43411 ZEND_NULL_HANDLER,
43412 ZEND_NULL_HANDLER,
43413 ZEND_NULL_HANDLER,
43414 ZEND_NULL_HANDLER,
43415 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43416 ZEND_NULL_HANDLER,
43417 ZEND_NULL_HANDLER,
43418 ZEND_NULL_HANDLER,
43419 ZEND_NULL_HANDLER,
43420 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43421 ZEND_NULL_HANDLER,
43422 ZEND_NULL_HANDLER,
43423 ZEND_NULL_HANDLER,
43424 ZEND_NULL_HANDLER,
43425 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43426 ZEND_NULL_HANDLER,
43427 ZEND_NULL_HANDLER,
43428 ZEND_NULL_HANDLER,
43429 ZEND_NULL_HANDLER,
43430 ZEND_NULL_HANDLER,
43431 ZEND_NULL_HANDLER,
43432 ZEND_NULL_HANDLER,
43433 ZEND_NULL_HANDLER,
43434 ZEND_NULL_HANDLER,
43435 ZEND_FREE_SPEC_TMP_HANDLER,
43436 ZEND_FREE_SPEC_TMP_HANDLER,
43437 ZEND_FREE_SPEC_TMP_HANDLER,
43438 ZEND_FREE_SPEC_TMP_HANDLER,
43439 ZEND_FREE_SPEC_TMP_HANDLER,
43440 ZEND_FREE_SPEC_VAR_HANDLER,
43441 ZEND_FREE_SPEC_VAR_HANDLER,
43442 ZEND_FREE_SPEC_VAR_HANDLER,
43443 ZEND_FREE_SPEC_VAR_HANDLER,
43444 ZEND_FREE_SPEC_VAR_HANDLER,
43445 ZEND_NULL_HANDLER,
43446 ZEND_NULL_HANDLER,
43447 ZEND_NULL_HANDLER,
43448 ZEND_NULL_HANDLER,
43449 ZEND_NULL_HANDLER,
43450 ZEND_NULL_HANDLER,
43451 ZEND_NULL_HANDLER,
43452 ZEND_NULL_HANDLER,
43453 ZEND_NULL_HANDLER,
43454 ZEND_NULL_HANDLER,
43455 ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER,
43456 ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER,
43457 ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER,
43458 ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER,
43459 ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER,
43460 ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER,
43461 ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER,
43462 ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER,
43463 ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER,
43464 ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER,
43465 ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER,
43466 ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER,
43467 ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER,
43468 ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
43469 ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
43470 ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
43471 ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER,
43472 ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER,
43473 ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
43474 ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
43475 ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
43476 ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER,
43477 ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER,
43478 ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER,
43479 ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER,
43480 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER,
43481 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER,
43482 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER,
43483 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER,
43484 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER,
43485 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER,
43486 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER,
43487 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER,
43488 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER,
43489 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER,
43490 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER,
43491 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER,
43492 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER,
43493 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
43494 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
43495 ZEND_NULL_HANDLER,
43496 ZEND_NULL_HANDLER,
43497 ZEND_NULL_HANDLER,
43498 ZEND_NULL_HANDLER,
43499 ZEND_NULL_HANDLER,
43500 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
43501 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER,
43502 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER,
43503 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
43504 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
43505 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
43506 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
43507 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
43508 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
43509 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
43510 ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
43511 ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
43512 ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
43513 ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
43514 ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
43515 ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
43516 ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
43517 ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
43518 ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
43519 ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
43520 ZEND_NULL_HANDLER,
43521 ZEND_NULL_HANDLER,
43522 ZEND_NULL_HANDLER,
43523 ZEND_NULL_HANDLER,
43524 ZEND_NULL_HANDLER,
43525 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
43526 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
43527 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
43528 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
43529 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
43530 ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER,
43531 ZEND_NULL_HANDLER,
43532 ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER,
43533 ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER,
43534 ZEND_NULL_HANDLER,
43535 ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER,
43536 ZEND_NULL_HANDLER,
43537 ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER,
43538 ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER,
43539 ZEND_NULL_HANDLER,
43540 ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER,
43541 ZEND_NULL_HANDLER,
43542 ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER,
43543 ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER,
43544 ZEND_NULL_HANDLER,
43545 ZEND_NULL_HANDLER,
43546 ZEND_NULL_HANDLER,
43547 ZEND_NULL_HANDLER,
43548 ZEND_NULL_HANDLER,
43549 ZEND_NULL_HANDLER,
43550 ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER,
43551 ZEND_NULL_HANDLER,
43552 ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER,
43553 ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER,
43554 ZEND_NULL_HANDLER,
43555 ZEND_NULL_HANDLER,
43556 ZEND_NULL_HANDLER,
43557 ZEND_NULL_HANDLER,
43558 ZEND_NULL_HANDLER,
43559 ZEND_NULL_HANDLER,
43560 ZEND_NULL_HANDLER,
43561 ZEND_NULL_HANDLER,
43562 ZEND_NULL_HANDLER,
43563 ZEND_NULL_HANDLER,
43564 ZEND_NULL_HANDLER,
43565 ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
43566 ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER,
43567 ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER,
43568 ZEND_NULL_HANDLER,
43569 ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER,
43570 ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER,
43571 ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER,
43572 ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER,
43573 ZEND_NULL_HANDLER,
43574 ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER,
43575 ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER,
43576 ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER,
43577 ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER,
43578 ZEND_NULL_HANDLER,
43579 ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER,
43580 ZEND_NULL_HANDLER,
43581 ZEND_NULL_HANDLER,
43582 ZEND_NULL_HANDLER,
43583 ZEND_NULL_HANDLER,
43584 ZEND_NULL_HANDLER,
43585 ZEND_NULL_HANDLER,
43586 ZEND_NULL_HANDLER,
43587 ZEND_NULL_HANDLER,
43588 ZEND_NULL_HANDLER,
43589 ZEND_NULL_HANDLER,
43590 ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER,
43591 ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER,
43592 ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER,
43593 ZEND_NULL_HANDLER,
43594 ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER,
43595 ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER,
43596 ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER,
43597 ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER,
43598 ZEND_NULL_HANDLER,
43599 ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER,
43600 ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER,
43601 ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER,
43602 ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER,
43603 ZEND_NULL_HANDLER,
43604 ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER,
43605 ZEND_FE_RESET_SPEC_CONST_HANDLER,
43606 ZEND_FE_RESET_SPEC_CONST_HANDLER,
43607 ZEND_FE_RESET_SPEC_CONST_HANDLER,
43608 ZEND_FE_RESET_SPEC_CONST_HANDLER,
43609 ZEND_FE_RESET_SPEC_CONST_HANDLER,
43610 ZEND_FE_RESET_SPEC_TMP_HANDLER,
43611 ZEND_FE_RESET_SPEC_TMP_HANDLER,
43612 ZEND_FE_RESET_SPEC_TMP_HANDLER,
43613 ZEND_FE_RESET_SPEC_TMP_HANDLER,
43614 ZEND_FE_RESET_SPEC_TMP_HANDLER,
43615 ZEND_FE_RESET_SPEC_VAR_HANDLER,
43616 ZEND_FE_RESET_SPEC_VAR_HANDLER,
43617 ZEND_FE_RESET_SPEC_VAR_HANDLER,
43618 ZEND_FE_RESET_SPEC_VAR_HANDLER,
43619 ZEND_FE_RESET_SPEC_VAR_HANDLER,
43620 ZEND_NULL_HANDLER,
43621 ZEND_NULL_HANDLER,
43622 ZEND_NULL_HANDLER,
43623 ZEND_NULL_HANDLER,
43624 ZEND_NULL_HANDLER,
43625 ZEND_FE_RESET_SPEC_CV_HANDLER,
43626 ZEND_FE_RESET_SPEC_CV_HANDLER,
43627 ZEND_FE_RESET_SPEC_CV_HANDLER,
43628 ZEND_FE_RESET_SPEC_CV_HANDLER,
43629 ZEND_FE_RESET_SPEC_CV_HANDLER,
43630 ZEND_NULL_HANDLER,
43631 ZEND_NULL_HANDLER,
43632 ZEND_NULL_HANDLER,
43633 ZEND_NULL_HANDLER,
43634 ZEND_NULL_HANDLER,
43635 ZEND_NULL_HANDLER,
43636 ZEND_NULL_HANDLER,
43637 ZEND_NULL_HANDLER,
43638 ZEND_NULL_HANDLER,
43639 ZEND_NULL_HANDLER,
43640 ZEND_FE_FETCH_SPEC_VAR_HANDLER,
43641 ZEND_FE_FETCH_SPEC_VAR_HANDLER,
43642 ZEND_FE_FETCH_SPEC_VAR_HANDLER,
43643 ZEND_FE_FETCH_SPEC_VAR_HANDLER,
43644 ZEND_FE_FETCH_SPEC_VAR_HANDLER,
43645 ZEND_NULL_HANDLER,
43646 ZEND_NULL_HANDLER,
43647 ZEND_NULL_HANDLER,
43648 ZEND_NULL_HANDLER,
43649 ZEND_NULL_HANDLER,
43650 ZEND_NULL_HANDLER,
43651 ZEND_NULL_HANDLER,
43652 ZEND_NULL_HANDLER,
43653 ZEND_NULL_HANDLER,
43654 ZEND_NULL_HANDLER,
43655 ZEND_EXIT_SPEC_CONST_HANDLER,
43656 ZEND_EXIT_SPEC_CONST_HANDLER,
43657 ZEND_EXIT_SPEC_CONST_HANDLER,
43658 ZEND_EXIT_SPEC_CONST_HANDLER,
43659 ZEND_EXIT_SPEC_CONST_HANDLER,
43660 ZEND_EXIT_SPEC_TMP_HANDLER,
43661 ZEND_EXIT_SPEC_TMP_HANDLER,
43662 ZEND_EXIT_SPEC_TMP_HANDLER,
43663 ZEND_EXIT_SPEC_TMP_HANDLER,
43664 ZEND_EXIT_SPEC_TMP_HANDLER,
43665 ZEND_EXIT_SPEC_VAR_HANDLER,
43666 ZEND_EXIT_SPEC_VAR_HANDLER,
43667 ZEND_EXIT_SPEC_VAR_HANDLER,
43668 ZEND_EXIT_SPEC_VAR_HANDLER,
43669 ZEND_EXIT_SPEC_VAR_HANDLER,
43670 ZEND_EXIT_SPEC_UNUSED_HANDLER,
43671 ZEND_EXIT_SPEC_UNUSED_HANDLER,
43672 ZEND_EXIT_SPEC_UNUSED_HANDLER,
43673 ZEND_EXIT_SPEC_UNUSED_HANDLER,
43674 ZEND_EXIT_SPEC_UNUSED_HANDLER,
43675 ZEND_EXIT_SPEC_CV_HANDLER,
43676 ZEND_EXIT_SPEC_CV_HANDLER,
43677 ZEND_EXIT_SPEC_CV_HANDLER,
43678 ZEND_EXIT_SPEC_CV_HANDLER,
43679 ZEND_EXIT_SPEC_CV_HANDLER,
43680 ZEND_FETCH_R_SPEC_CONST_CONST_HANDLER,
43681 ZEND_NULL_HANDLER,
43682 ZEND_FETCH_R_SPEC_CONST_VAR_HANDLER,
43683 ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER,
43684 ZEND_NULL_HANDLER,
43685 ZEND_FETCH_R_SPEC_TMP_CONST_HANDLER,
43686 ZEND_NULL_HANDLER,
43687 ZEND_FETCH_R_SPEC_TMP_VAR_HANDLER,
43688 ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER,
43689 ZEND_NULL_HANDLER,
43690 ZEND_FETCH_R_SPEC_VAR_CONST_HANDLER,
43691 ZEND_NULL_HANDLER,
43692 ZEND_FETCH_R_SPEC_VAR_VAR_HANDLER,
43693 ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER,
43694 ZEND_NULL_HANDLER,
43695 ZEND_NULL_HANDLER,
43696 ZEND_NULL_HANDLER,
43697 ZEND_NULL_HANDLER,
43698 ZEND_NULL_HANDLER,
43699 ZEND_NULL_HANDLER,
43700 ZEND_FETCH_R_SPEC_CV_CONST_HANDLER,
43701 ZEND_NULL_HANDLER,
43702 ZEND_FETCH_R_SPEC_CV_VAR_HANDLER,
43703 ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER,
43704 ZEND_NULL_HANDLER,
43705 ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER,
43706 ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER,
43707 ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER,
43708 ZEND_NULL_HANDLER,
43709 ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER,
43710 ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER,
43711 ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER,
43712 ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER,
43713 ZEND_NULL_HANDLER,
43714 ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER,
43715 ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER,
43716 ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER,
43717 ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER,
43718 ZEND_NULL_HANDLER,
43719 ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER,
43720 ZEND_NULL_HANDLER,
43721 ZEND_NULL_HANDLER,
43722 ZEND_NULL_HANDLER,
43723 ZEND_NULL_HANDLER,
43724 ZEND_NULL_HANDLER,
43725 ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
43726 ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER,
43727 ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER,
43728 ZEND_NULL_HANDLER,
43729 ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
43730 ZEND_NULL_HANDLER,
43731 ZEND_NULL_HANDLER,
43732 ZEND_NULL_HANDLER,
43733 ZEND_NULL_HANDLER,
43734 ZEND_NULL_HANDLER,
43735 ZEND_NULL_HANDLER,
43736 ZEND_NULL_HANDLER,
43737 ZEND_NULL_HANDLER,
43738 ZEND_NULL_HANDLER,
43739 ZEND_NULL_HANDLER,
43740 ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER,
43741 ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER,
43742 ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER,
43743 ZEND_NULL_HANDLER,
43744 ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER,
43745 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER,
43746 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER,
43747 ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER,
43748 ZEND_NULL_HANDLER,
43749 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER,
43750 ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER,
43751 ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER,
43752 ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER,
43753 ZEND_NULL_HANDLER,
43754 ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
43755 ZEND_FETCH_W_SPEC_CONST_CONST_HANDLER,
43756 ZEND_NULL_HANDLER,
43757 ZEND_FETCH_W_SPEC_CONST_VAR_HANDLER,
43758 ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER,
43759 ZEND_NULL_HANDLER,
43760 ZEND_FETCH_W_SPEC_TMP_CONST_HANDLER,
43761 ZEND_NULL_HANDLER,
43762 ZEND_FETCH_W_SPEC_TMP_VAR_HANDLER,
43763 ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER,
43764 ZEND_NULL_HANDLER,
43765 ZEND_FETCH_W_SPEC_VAR_CONST_HANDLER,
43766 ZEND_NULL_HANDLER,
43767 ZEND_FETCH_W_SPEC_VAR_VAR_HANDLER,
43768 ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER,
43769 ZEND_NULL_HANDLER,
43770 ZEND_NULL_HANDLER,
43771 ZEND_NULL_HANDLER,
43772 ZEND_NULL_HANDLER,
43773 ZEND_NULL_HANDLER,
43774 ZEND_NULL_HANDLER,
43775 ZEND_FETCH_W_SPEC_CV_CONST_HANDLER,
43776 ZEND_NULL_HANDLER,
43777 ZEND_FETCH_W_SPEC_CV_VAR_HANDLER,
43778 ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER,
43779 ZEND_NULL_HANDLER,
43780 ZEND_NULL_HANDLER,
43781 ZEND_NULL_HANDLER,
43782 ZEND_NULL_HANDLER,
43783 ZEND_NULL_HANDLER,
43784 ZEND_NULL_HANDLER,
43785 ZEND_NULL_HANDLER,
43786 ZEND_NULL_HANDLER,
43787 ZEND_NULL_HANDLER,
43788 ZEND_NULL_HANDLER,
43789 ZEND_NULL_HANDLER,
43790 ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
43791 ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER,
43792 ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER,
43793 ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
43794 ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
43795 ZEND_NULL_HANDLER,
43796 ZEND_NULL_HANDLER,
43797 ZEND_NULL_HANDLER,
43798 ZEND_NULL_HANDLER,
43799 ZEND_NULL_HANDLER,
43800 ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
43801 ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER,
43802 ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER,
43803 ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
43804 ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
43805 ZEND_NULL_HANDLER,
43806 ZEND_NULL_HANDLER,
43807 ZEND_NULL_HANDLER,
43808 ZEND_NULL_HANDLER,
43809 ZEND_NULL_HANDLER,
43810 ZEND_NULL_HANDLER,
43811 ZEND_NULL_HANDLER,
43812 ZEND_NULL_HANDLER,
43813 ZEND_NULL_HANDLER,
43814 ZEND_NULL_HANDLER,
43815 ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER,
43816 ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER,
43817 ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER,
43818 ZEND_NULL_HANDLER,
43819 ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER,
43820 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER,
43821 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER,
43822 ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER,
43823 ZEND_NULL_HANDLER,
43824 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER,
43825 ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER,
43826 ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER,
43827 ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER,
43828 ZEND_NULL_HANDLER,
43829 ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
43830 ZEND_FETCH_RW_SPEC_CONST_CONST_HANDLER,
43831 ZEND_NULL_HANDLER,
43832 ZEND_FETCH_RW_SPEC_CONST_VAR_HANDLER,
43833 ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER,
43834 ZEND_NULL_HANDLER,
43835 ZEND_FETCH_RW_SPEC_TMP_CONST_HANDLER,
43836 ZEND_NULL_HANDLER,
43837 ZEND_FETCH_RW_SPEC_TMP_VAR_HANDLER,
43838 ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER,
43839 ZEND_NULL_HANDLER,
43840 ZEND_FETCH_RW_SPEC_VAR_CONST_HANDLER,
43841 ZEND_NULL_HANDLER,
43842 ZEND_FETCH_RW_SPEC_VAR_VAR_HANDLER,
43843 ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER,
43844 ZEND_NULL_HANDLER,
43845 ZEND_NULL_HANDLER,
43846 ZEND_NULL_HANDLER,
43847 ZEND_NULL_HANDLER,
43848 ZEND_NULL_HANDLER,
43849 ZEND_NULL_HANDLER,
43850 ZEND_FETCH_RW_SPEC_CV_CONST_HANDLER,
43851 ZEND_NULL_HANDLER,
43852 ZEND_FETCH_RW_SPEC_CV_VAR_HANDLER,
43853 ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER,
43854 ZEND_NULL_HANDLER,
43855 ZEND_NULL_HANDLER,
43856 ZEND_NULL_HANDLER,
43857 ZEND_NULL_HANDLER,
43858 ZEND_NULL_HANDLER,
43859 ZEND_NULL_HANDLER,
43860 ZEND_NULL_HANDLER,
43861 ZEND_NULL_HANDLER,
43862 ZEND_NULL_HANDLER,
43863 ZEND_NULL_HANDLER,
43864 ZEND_NULL_HANDLER,
43865 ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
43866 ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER,
43867 ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER,
43868 ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
43869 ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
43870 ZEND_NULL_HANDLER,
43871 ZEND_NULL_HANDLER,
43872 ZEND_NULL_HANDLER,
43873 ZEND_NULL_HANDLER,
43874 ZEND_NULL_HANDLER,
43875 ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
43876 ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER,
43877 ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER,
43878 ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
43879 ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
43880 ZEND_NULL_HANDLER,
43881 ZEND_NULL_HANDLER,
43882 ZEND_NULL_HANDLER,
43883 ZEND_NULL_HANDLER,
43884 ZEND_NULL_HANDLER,
43885 ZEND_NULL_HANDLER,
43886 ZEND_NULL_HANDLER,
43887 ZEND_NULL_HANDLER,
43888 ZEND_NULL_HANDLER,
43889 ZEND_NULL_HANDLER,
43890 ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER,
43891 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER,
43892 ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER,
43893 ZEND_NULL_HANDLER,
43894 ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER,
43895 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER,
43896 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER,
43897 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER,
43898 ZEND_NULL_HANDLER,
43899 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER,
43900 ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER,
43901 ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER,
43902 ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER,
43903 ZEND_NULL_HANDLER,
43904 ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
43905 ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER,
43906 ZEND_NULL_HANDLER,
43907 ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER,
43908 ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER,
43909 ZEND_NULL_HANDLER,
43910 ZEND_FETCH_IS_SPEC_TMP_CONST_HANDLER,
43911 ZEND_NULL_HANDLER,
43912 ZEND_FETCH_IS_SPEC_TMP_VAR_HANDLER,
43913 ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER,
43914 ZEND_NULL_HANDLER,
43915 ZEND_FETCH_IS_SPEC_VAR_CONST_HANDLER,
43916 ZEND_NULL_HANDLER,
43917 ZEND_FETCH_IS_SPEC_VAR_VAR_HANDLER,
43918 ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER,
43919 ZEND_NULL_HANDLER,
43920 ZEND_NULL_HANDLER,
43921 ZEND_NULL_HANDLER,
43922 ZEND_NULL_HANDLER,
43923 ZEND_NULL_HANDLER,
43924 ZEND_NULL_HANDLER,
43925 ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER,
43926 ZEND_NULL_HANDLER,
43927 ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER,
43928 ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
43929 ZEND_NULL_HANDLER,
43930 ZEND_NULL_HANDLER,
43931 ZEND_NULL_HANDLER,
43932 ZEND_NULL_HANDLER,
43933 ZEND_NULL_HANDLER,
43934 ZEND_NULL_HANDLER,
43935 ZEND_NULL_HANDLER,
43936 ZEND_NULL_HANDLER,
43937 ZEND_NULL_HANDLER,
43938 ZEND_NULL_HANDLER,
43939 ZEND_NULL_HANDLER,
43940 ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER,
43941 ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER,
43942 ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER,
43943 ZEND_NULL_HANDLER,
43944 ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER,
43945 ZEND_NULL_HANDLER,
43946 ZEND_NULL_HANDLER,
43947 ZEND_NULL_HANDLER,
43948 ZEND_NULL_HANDLER,
43949 ZEND_NULL_HANDLER,
43950 ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
43951 ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER,
43952 ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER,
43953 ZEND_NULL_HANDLER,
43954 ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
43955 ZEND_NULL_HANDLER,
43956 ZEND_NULL_HANDLER,
43957 ZEND_NULL_HANDLER,
43958 ZEND_NULL_HANDLER,
43959 ZEND_NULL_HANDLER,
43960 ZEND_NULL_HANDLER,
43961 ZEND_NULL_HANDLER,
43962 ZEND_NULL_HANDLER,
43963 ZEND_NULL_HANDLER,
43964 ZEND_NULL_HANDLER,
43965 ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER,
43966 ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER,
43967 ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER,
43968 ZEND_NULL_HANDLER,
43969 ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER,
43970 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER,
43971 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER,
43972 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER,
43973 ZEND_NULL_HANDLER,
43974 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER,
43975 ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER,
43976 ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER,
43977 ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER,
43978 ZEND_NULL_HANDLER,
43979 ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
43980 ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
43981 ZEND_NULL_HANDLER,
43982 ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER,
43983 ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
43984 ZEND_NULL_HANDLER,
43985 ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
43986 ZEND_NULL_HANDLER,
43987 ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER,
43988 ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
43989 ZEND_NULL_HANDLER,
43990 ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
43991 ZEND_NULL_HANDLER,
43992 ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
43993 ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
43994 ZEND_NULL_HANDLER,
43995 ZEND_NULL_HANDLER,
43996 ZEND_NULL_HANDLER,
43997 ZEND_NULL_HANDLER,
43998 ZEND_NULL_HANDLER,
43999 ZEND_NULL_HANDLER,
44000 ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER,
44001 ZEND_NULL_HANDLER,
44002 ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER,
44003 ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
44004 ZEND_NULL_HANDLER,
44005 ZEND_NULL_HANDLER,
44006 ZEND_NULL_HANDLER,
44007 ZEND_NULL_HANDLER,
44008 ZEND_NULL_HANDLER,
44009 ZEND_NULL_HANDLER,
44010 ZEND_NULL_HANDLER,
44011 ZEND_NULL_HANDLER,
44012 ZEND_NULL_HANDLER,
44013 ZEND_NULL_HANDLER,
44014 ZEND_NULL_HANDLER,
44015 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
44016 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
44017 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
44018 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
44019 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
44020 ZEND_NULL_HANDLER,
44021 ZEND_NULL_HANDLER,
44022 ZEND_NULL_HANDLER,
44023 ZEND_NULL_HANDLER,
44024 ZEND_NULL_HANDLER,
44025 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
44026 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER,
44027 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER,
44028 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
44029 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
44030 ZEND_NULL_HANDLER,
44031 ZEND_NULL_HANDLER,
44032 ZEND_NULL_HANDLER,
44033 ZEND_NULL_HANDLER,
44034 ZEND_NULL_HANDLER,
44035 ZEND_NULL_HANDLER,
44036 ZEND_NULL_HANDLER,
44037 ZEND_NULL_HANDLER,
44038 ZEND_NULL_HANDLER,
44039 ZEND_NULL_HANDLER,
44040 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
44041 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
44042 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
44043 ZEND_NULL_HANDLER,
44044 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER,
44045 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
44046 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER,
44047 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER,
44048 ZEND_NULL_HANDLER,
44049 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER,
44050 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER,
44051 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER,
44052 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER,
44053 ZEND_NULL_HANDLER,
44054 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
44055 ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER,
44056 ZEND_NULL_HANDLER,
44057 ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER,
44058 ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER,
44059 ZEND_NULL_HANDLER,
44060 ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER,
44061 ZEND_NULL_HANDLER,
44062 ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER,
44063 ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER,
44064 ZEND_NULL_HANDLER,
44065 ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER,
44066 ZEND_NULL_HANDLER,
44067 ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER,
44068 ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER,
44069 ZEND_NULL_HANDLER,
44070 ZEND_NULL_HANDLER,
44071 ZEND_NULL_HANDLER,
44072 ZEND_NULL_HANDLER,
44073 ZEND_NULL_HANDLER,
44074 ZEND_NULL_HANDLER,
44075 ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER,
44076 ZEND_NULL_HANDLER,
44077 ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER,
44078 ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER,
44079 ZEND_NULL_HANDLER,
44080 ZEND_NULL_HANDLER,
44081 ZEND_NULL_HANDLER,
44082 ZEND_NULL_HANDLER,
44083 ZEND_NULL_HANDLER,
44084 ZEND_NULL_HANDLER,
44085 ZEND_NULL_HANDLER,
44086 ZEND_NULL_HANDLER,
44087 ZEND_NULL_HANDLER,
44088 ZEND_NULL_HANDLER,
44089 ZEND_NULL_HANDLER,
44090 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
44091 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER,
44092 ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER,
44093 ZEND_NULL_HANDLER,
44094 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
44095 ZEND_NULL_HANDLER,
44096 ZEND_NULL_HANDLER,
44097 ZEND_NULL_HANDLER,
44098 ZEND_NULL_HANDLER,
44099 ZEND_NULL_HANDLER,
44100 ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
44101 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER,
44102 ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER,
44103 ZEND_NULL_HANDLER,
44104 ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
44105 ZEND_NULL_HANDLER,
44106 ZEND_NULL_HANDLER,
44107 ZEND_NULL_HANDLER,
44108 ZEND_NULL_HANDLER,
44109 ZEND_NULL_HANDLER,
44110 ZEND_NULL_HANDLER,
44111 ZEND_NULL_HANDLER,
44112 ZEND_NULL_HANDLER,
44113 ZEND_NULL_HANDLER,
44114 ZEND_NULL_HANDLER,
44115 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER,
44116 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER,
44117 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER,
44118 ZEND_NULL_HANDLER,
44119 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER,
44120 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER,
44121 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER,
44122 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER,
44123 ZEND_NULL_HANDLER,
44124 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER,
44125 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER,
44126 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER,
44127 ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER,
44128 ZEND_NULL_HANDLER,
44129 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER,
44130 ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER,
44131 ZEND_NULL_HANDLER,
44132 ZEND_NULL_HANDLER,
44133 ZEND_NULL_HANDLER,
44134 ZEND_NULL_HANDLER,
44135 ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER,
44136 ZEND_NULL_HANDLER,
44137 ZEND_NULL_HANDLER,
44138 ZEND_NULL_HANDLER,
44139 ZEND_NULL_HANDLER,
44140 ZEND_NULL_HANDLER,
44141 ZEND_NULL_HANDLER,
44142 ZEND_NULL_HANDLER,
44143 ZEND_NULL_HANDLER,
44144 ZEND_NULL_HANDLER,
44145 ZEND_NULL_HANDLER,
44146 ZEND_NULL_HANDLER,
44147 ZEND_NULL_HANDLER,
44148 ZEND_NULL_HANDLER,
44149 ZEND_NULL_HANDLER,
44150 ZEND_NULL_HANDLER,
44151 ZEND_NULL_HANDLER,
44152 ZEND_NULL_HANDLER,
44153 ZEND_NULL_HANDLER,
44154 ZEND_NULL_HANDLER,
44155 ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER,
44156 ZEND_NULL_HANDLER,
44157 ZEND_NULL_HANDLER,
44158 ZEND_NULL_HANDLER,
44159 ZEND_NULL_HANDLER,
44160 ZEND_NULL_HANDLER,
44161 ZEND_NULL_HANDLER,
44162 ZEND_NULL_HANDLER,
44163 ZEND_NULL_HANDLER,
44164 ZEND_NULL_HANDLER,
44165 ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER,
44166 ZEND_NULL_HANDLER,
44167 ZEND_NULL_HANDLER,
44168 ZEND_NULL_HANDLER,
44169 ZEND_NULL_HANDLER,
44170 ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
44171 ZEND_NULL_HANDLER,
44172 ZEND_NULL_HANDLER,
44173 ZEND_NULL_HANDLER,
44174 ZEND_NULL_HANDLER,
44175 ZEND_NULL_HANDLER,
44176 ZEND_NULL_HANDLER,
44177 ZEND_NULL_HANDLER,
44178 ZEND_NULL_HANDLER,
44179 ZEND_NULL_HANDLER,
44180 ZEND_GOTO_SPEC_CONST_HANDLER,
44181 ZEND_NULL_HANDLER,
44182 ZEND_NULL_HANDLER,
44183 ZEND_NULL_HANDLER,
44184 ZEND_NULL_HANDLER,
44185 ZEND_GOTO_SPEC_CONST_HANDLER,
44186 ZEND_NULL_HANDLER,
44187 ZEND_NULL_HANDLER,
44188 ZEND_NULL_HANDLER,
44189 ZEND_NULL_HANDLER,
44190 ZEND_GOTO_SPEC_CONST_HANDLER,
44191 ZEND_NULL_HANDLER,
44192 ZEND_NULL_HANDLER,
44193 ZEND_NULL_HANDLER,
44194 ZEND_NULL_HANDLER,
44195 ZEND_GOTO_SPEC_CONST_HANDLER,
44196 ZEND_NULL_HANDLER,
44197 ZEND_NULL_HANDLER,
44198 ZEND_NULL_HANDLER,
44199 ZEND_NULL_HANDLER,
44200 ZEND_GOTO_SPEC_CONST_HANDLER,
44201 ZEND_NULL_HANDLER,
44202 ZEND_NULL_HANDLER,
44203 ZEND_NULL_HANDLER,
44204 ZEND_NULL_HANDLER,
44205 ZEND_EXT_STMT_SPEC_HANDLER,
44206 ZEND_EXT_STMT_SPEC_HANDLER,
44207 ZEND_EXT_STMT_SPEC_HANDLER,
44208 ZEND_EXT_STMT_SPEC_HANDLER,
44209 ZEND_EXT_STMT_SPEC_HANDLER,
44210 ZEND_EXT_STMT_SPEC_HANDLER,
44211 ZEND_EXT_STMT_SPEC_HANDLER,
44212 ZEND_EXT_STMT_SPEC_HANDLER,
44213 ZEND_EXT_STMT_SPEC_HANDLER,
44214 ZEND_EXT_STMT_SPEC_HANDLER,
44215 ZEND_EXT_STMT_SPEC_HANDLER,
44216 ZEND_EXT_STMT_SPEC_HANDLER,
44217 ZEND_EXT_STMT_SPEC_HANDLER,
44218 ZEND_EXT_STMT_SPEC_HANDLER,
44219 ZEND_EXT_STMT_SPEC_HANDLER,
44220 ZEND_EXT_STMT_SPEC_HANDLER,
44221 ZEND_EXT_STMT_SPEC_HANDLER,
44222 ZEND_EXT_STMT_SPEC_HANDLER,
44223 ZEND_EXT_STMT_SPEC_HANDLER,
44224 ZEND_EXT_STMT_SPEC_HANDLER,
44225 ZEND_EXT_STMT_SPEC_HANDLER,
44226 ZEND_EXT_STMT_SPEC_HANDLER,
44227 ZEND_EXT_STMT_SPEC_HANDLER,
44228 ZEND_EXT_STMT_SPEC_HANDLER,
44229 ZEND_EXT_STMT_SPEC_HANDLER,
44230 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44231 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44232 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44233 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44234 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44235 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44236 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44237 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44238 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44239 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44240 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44241 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44242 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44243 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44244 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44245 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44246 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44247 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44248 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44249 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44250 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44251 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44252 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44253 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44254 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
44255 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44256 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44257 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44258 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44259 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44260 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44261 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44262 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44263 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44264 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44265 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44266 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44267 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44268 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44269 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44270 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44271 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44272 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44273 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44274 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44275 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44276 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44277 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44278 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44279 ZEND_EXT_FCALL_END_SPEC_HANDLER,
44280 ZEND_EXT_NOP_SPEC_HANDLER,
44281 ZEND_EXT_NOP_SPEC_HANDLER,
44282 ZEND_EXT_NOP_SPEC_HANDLER,
44283 ZEND_EXT_NOP_SPEC_HANDLER,
44284 ZEND_EXT_NOP_SPEC_HANDLER,
44285 ZEND_EXT_NOP_SPEC_HANDLER,
44286 ZEND_EXT_NOP_SPEC_HANDLER,
44287 ZEND_EXT_NOP_SPEC_HANDLER,
44288 ZEND_EXT_NOP_SPEC_HANDLER,
44289 ZEND_EXT_NOP_SPEC_HANDLER,
44290 ZEND_EXT_NOP_SPEC_HANDLER,
44291 ZEND_EXT_NOP_SPEC_HANDLER,
44292 ZEND_EXT_NOP_SPEC_HANDLER,
44293 ZEND_EXT_NOP_SPEC_HANDLER,
44294 ZEND_EXT_NOP_SPEC_HANDLER,
44295 ZEND_EXT_NOP_SPEC_HANDLER,
44296 ZEND_EXT_NOP_SPEC_HANDLER,
44297 ZEND_EXT_NOP_SPEC_HANDLER,
44298 ZEND_EXT_NOP_SPEC_HANDLER,
44299 ZEND_EXT_NOP_SPEC_HANDLER,
44300 ZEND_EXT_NOP_SPEC_HANDLER,
44301 ZEND_EXT_NOP_SPEC_HANDLER,
44302 ZEND_EXT_NOP_SPEC_HANDLER,
44303 ZEND_EXT_NOP_SPEC_HANDLER,
44304 ZEND_EXT_NOP_SPEC_HANDLER,
44305 ZEND_TICKS_SPEC_HANDLER,
44306 ZEND_TICKS_SPEC_HANDLER,
44307 ZEND_TICKS_SPEC_HANDLER,
44308 ZEND_TICKS_SPEC_HANDLER,
44309 ZEND_TICKS_SPEC_HANDLER,
44310 ZEND_TICKS_SPEC_HANDLER,
44311 ZEND_TICKS_SPEC_HANDLER,
44312 ZEND_TICKS_SPEC_HANDLER,
44313 ZEND_TICKS_SPEC_HANDLER,
44314 ZEND_TICKS_SPEC_HANDLER,
44315 ZEND_TICKS_SPEC_HANDLER,
44316 ZEND_TICKS_SPEC_HANDLER,
44317 ZEND_TICKS_SPEC_HANDLER,
44318 ZEND_TICKS_SPEC_HANDLER,
44319 ZEND_TICKS_SPEC_HANDLER,
44320 ZEND_TICKS_SPEC_HANDLER,
44321 ZEND_TICKS_SPEC_HANDLER,
44322 ZEND_TICKS_SPEC_HANDLER,
44323 ZEND_TICKS_SPEC_HANDLER,
44324 ZEND_TICKS_SPEC_HANDLER,
44325 ZEND_TICKS_SPEC_HANDLER,
44326 ZEND_TICKS_SPEC_HANDLER,
44327 ZEND_TICKS_SPEC_HANDLER,
44328 ZEND_TICKS_SPEC_HANDLER,
44329 ZEND_TICKS_SPEC_HANDLER,
44330 ZEND_NULL_HANDLER,
44331 ZEND_NULL_HANDLER,
44332 ZEND_NULL_HANDLER,
44333 ZEND_NULL_HANDLER,
44334 ZEND_NULL_HANDLER,
44335 ZEND_NULL_HANDLER,
44336 ZEND_NULL_HANDLER,
44337 ZEND_NULL_HANDLER,
44338 ZEND_NULL_HANDLER,
44339 ZEND_NULL_HANDLER,
44340 ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
44341 ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
44342 ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
44343 ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
44344 ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
44345 ZEND_NULL_HANDLER,
44346 ZEND_NULL_HANDLER,
44347 ZEND_NULL_HANDLER,
44348 ZEND_NULL_HANDLER,
44349 ZEND_NULL_HANDLER,
44350 ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
44351 ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
44352 ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
44353 ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
44354 ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
44355 ZEND_NULL_HANDLER,
44356 ZEND_NULL_HANDLER,
44357 ZEND_NULL_HANDLER,
44358 ZEND_NULL_HANDLER,
44359 ZEND_CATCH_SPEC_CONST_CV_HANDLER,
44360 ZEND_NULL_HANDLER,
44361 ZEND_NULL_HANDLER,
44362 ZEND_NULL_HANDLER,
44363 ZEND_NULL_HANDLER,
44364 ZEND_NULL_HANDLER,
44365 ZEND_NULL_HANDLER,
44366 ZEND_NULL_HANDLER,
44367 ZEND_NULL_HANDLER,
44368 ZEND_NULL_HANDLER,
44369 ZEND_NULL_HANDLER,
44370 ZEND_NULL_HANDLER,
44371 ZEND_NULL_HANDLER,
44372 ZEND_NULL_HANDLER,
44373 ZEND_NULL_HANDLER,
44374 ZEND_NULL_HANDLER,
44375 ZEND_NULL_HANDLER,
44376 ZEND_NULL_HANDLER,
44377 ZEND_NULL_HANDLER,
44378 ZEND_NULL_HANDLER,
44379 ZEND_NULL_HANDLER,
44380 ZEND_THROW_SPEC_CONST_HANDLER,
44381 ZEND_THROW_SPEC_CONST_HANDLER,
44382 ZEND_THROW_SPEC_CONST_HANDLER,
44383 ZEND_THROW_SPEC_CONST_HANDLER,
44384 ZEND_THROW_SPEC_CONST_HANDLER,
44385 ZEND_THROW_SPEC_TMP_HANDLER,
44386 ZEND_THROW_SPEC_TMP_HANDLER,
44387 ZEND_THROW_SPEC_TMP_HANDLER,
44388 ZEND_THROW_SPEC_TMP_HANDLER,
44389 ZEND_THROW_SPEC_TMP_HANDLER,
44390 ZEND_THROW_SPEC_VAR_HANDLER,
44391 ZEND_THROW_SPEC_VAR_HANDLER,
44392 ZEND_THROW_SPEC_VAR_HANDLER,
44393 ZEND_THROW_SPEC_VAR_HANDLER,
44394 ZEND_THROW_SPEC_VAR_HANDLER,
44395 ZEND_NULL_HANDLER,
44396 ZEND_NULL_HANDLER,
44397 ZEND_NULL_HANDLER,
44398 ZEND_NULL_HANDLER,
44399 ZEND_NULL_HANDLER,
44400 ZEND_THROW_SPEC_CV_HANDLER,
44401 ZEND_THROW_SPEC_CV_HANDLER,
44402 ZEND_THROW_SPEC_CV_HANDLER,
44403 ZEND_THROW_SPEC_CV_HANDLER,
44404 ZEND_THROW_SPEC_CV_HANDLER,
44405 ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
44406 ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
44407 ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
44408 ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
44409 ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
44410 ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
44411 ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
44412 ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
44413 ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
44414 ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
44415 ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
44416 ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
44417 ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
44418 ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
44419 ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
44420 ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
44421 ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
44422 ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
44423 ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
44424 ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
44425 ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
44426 ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
44427 ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
44428 ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
44429 ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
44430 ZEND_CLONE_SPEC_CONST_HANDLER,
44431 ZEND_CLONE_SPEC_CONST_HANDLER,
44432 ZEND_CLONE_SPEC_CONST_HANDLER,
44433 ZEND_CLONE_SPEC_CONST_HANDLER,
44434 ZEND_CLONE_SPEC_CONST_HANDLER,
44435 ZEND_CLONE_SPEC_TMP_HANDLER,
44436 ZEND_CLONE_SPEC_TMP_HANDLER,
44437 ZEND_CLONE_SPEC_TMP_HANDLER,
44438 ZEND_CLONE_SPEC_TMP_HANDLER,
44439 ZEND_CLONE_SPEC_TMP_HANDLER,
44440 ZEND_CLONE_SPEC_VAR_HANDLER,
44441 ZEND_CLONE_SPEC_VAR_HANDLER,
44442 ZEND_CLONE_SPEC_VAR_HANDLER,
44443 ZEND_CLONE_SPEC_VAR_HANDLER,
44444 ZEND_CLONE_SPEC_VAR_HANDLER,
44445 ZEND_CLONE_SPEC_UNUSED_HANDLER,
44446 ZEND_CLONE_SPEC_UNUSED_HANDLER,
44447 ZEND_CLONE_SPEC_UNUSED_HANDLER,
44448 ZEND_CLONE_SPEC_UNUSED_HANDLER,
44449 ZEND_CLONE_SPEC_UNUSED_HANDLER,
44450 ZEND_CLONE_SPEC_CV_HANDLER,
44451 ZEND_CLONE_SPEC_CV_HANDLER,
44452 ZEND_CLONE_SPEC_CV_HANDLER,
44453 ZEND_CLONE_SPEC_CV_HANDLER,
44454 ZEND_CLONE_SPEC_CV_HANDLER,
44455 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
44456 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
44457 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
44458 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
44459 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
44460 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
44461 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
44462 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
44463 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
44464 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
44465 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
44466 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
44467 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
44468 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
44469 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
44470 ZEND_NULL_HANDLER,
44471 ZEND_NULL_HANDLER,
44472 ZEND_NULL_HANDLER,
44473 ZEND_NULL_HANDLER,
44474 ZEND_NULL_HANDLER,
44475 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
44476 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
44477 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
44478 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
44479 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
44480 ZEND_NULL_HANDLER,
44481 ZEND_NULL_HANDLER,
44482 ZEND_NULL_HANDLER,
44483 ZEND_NULL_HANDLER,
44484 ZEND_NULL_HANDLER,
44485 ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER,
44486 ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER,
44487 ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER,
44488 ZEND_NULL_HANDLER,
44489 ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER,
44490 ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
44491 ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER,
44492 ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER,
44493 ZEND_NULL_HANDLER,
44494 ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER,
44495 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
44496 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER,
44497 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER,
44498 ZEND_NULL_HANDLER,
44499 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
44500 ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER,
44501 ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER,
44502 ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER,
44503 ZEND_NULL_HANDLER,
44504 ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER,
44505 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
44506 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER,
44507 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER,
44508 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER,
44509 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER,
44510 ZEND_NULL_HANDLER,
44511 ZEND_NULL_HANDLER,
44512 ZEND_NULL_HANDLER,
44513 ZEND_NULL_HANDLER,
44514 ZEND_NULL_HANDLER,
44515 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
44516 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER,
44517 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER,
44518 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER,
44519 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER,
44520 ZEND_NULL_HANDLER,
44521 ZEND_NULL_HANDLER,
44522 ZEND_NULL_HANDLER,
44523 ZEND_NULL_HANDLER,
44524 ZEND_NULL_HANDLER,
44525 ZEND_NULL_HANDLER,
44526 ZEND_NULL_HANDLER,
44527 ZEND_NULL_HANDLER,
44528 ZEND_NULL_HANDLER,
44529 ZEND_NULL_HANDLER,
44530 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER,
44531 ZEND_NULL_HANDLER,
44532 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER,
44533 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER,
44534 ZEND_NULL_HANDLER,
44535 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER,
44536 ZEND_NULL_HANDLER,
44537 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER,
44538 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER,
44539 ZEND_NULL_HANDLER,
44540 ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER,
44541 ZEND_NULL_HANDLER,
44542 ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER,
44543 ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER,
44544 ZEND_NULL_HANDLER,
44545 ZEND_NULL_HANDLER,
44546 ZEND_NULL_HANDLER,
44547 ZEND_NULL_HANDLER,
44548 ZEND_NULL_HANDLER,
44549 ZEND_NULL_HANDLER,
44550 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER,
44551 ZEND_NULL_HANDLER,
44552 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER,
44553 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER,
44554 ZEND_NULL_HANDLER,
44555 ZEND_NULL_HANDLER,
44556 ZEND_NULL_HANDLER,
44557 ZEND_NULL_HANDLER,
44558 ZEND_NULL_HANDLER,
44559 ZEND_NULL_HANDLER,
44560 ZEND_NULL_HANDLER,
44561 ZEND_NULL_HANDLER,
44562 ZEND_NULL_HANDLER,
44563 ZEND_NULL_HANDLER,
44564 ZEND_NULL_HANDLER,
44565 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER,
44566 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER,
44567 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER,
44568 ZEND_NULL_HANDLER,
44569 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER,
44570 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER,
44571 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER,
44572 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER,
44573 ZEND_NULL_HANDLER,
44574 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER,
44575 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER,
44576 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER,
44577 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER,
44578 ZEND_NULL_HANDLER,
44579 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER,
44580 ZEND_NULL_HANDLER,
44581 ZEND_NULL_HANDLER,
44582 ZEND_NULL_HANDLER,
44583 ZEND_NULL_HANDLER,
44584 ZEND_NULL_HANDLER,
44585 ZEND_NULL_HANDLER,
44586 ZEND_NULL_HANDLER,
44587 ZEND_NULL_HANDLER,
44588 ZEND_NULL_HANDLER,
44589 ZEND_NULL_HANDLER,
44590 ZEND_NULL_HANDLER,
44591 ZEND_NULL_HANDLER,
44592 ZEND_NULL_HANDLER,
44593 ZEND_NULL_HANDLER,
44594 ZEND_NULL_HANDLER,
44595 ZEND_NULL_HANDLER,
44596 ZEND_NULL_HANDLER,
44597 ZEND_NULL_HANDLER,
44598 ZEND_NULL_HANDLER,
44599 ZEND_NULL_HANDLER,
44600 ZEND_NULL_HANDLER,
44601 ZEND_NULL_HANDLER,
44602 ZEND_NULL_HANDLER,
44603 ZEND_NULL_HANDLER,
44604 ZEND_NULL_HANDLER,
44605 ZEND_NULL_HANDLER,
44606 ZEND_NULL_HANDLER,
44607 ZEND_NULL_HANDLER,
44608 ZEND_NULL_HANDLER,
44609 ZEND_NULL_HANDLER,
44610 ZEND_NULL_HANDLER,
44611 ZEND_NULL_HANDLER,
44612 ZEND_NULL_HANDLER,
44613 ZEND_NULL_HANDLER,
44614 ZEND_NULL_HANDLER,
44615 ZEND_NULL_HANDLER,
44616 ZEND_NULL_HANDLER,
44617 ZEND_NULL_HANDLER,
44618 ZEND_NULL_HANDLER,
44619 ZEND_NULL_HANDLER,
44620 ZEND_NULL_HANDLER,
44621 ZEND_NULL_HANDLER,
44622 ZEND_NULL_HANDLER,
44623 ZEND_NULL_HANDLER,
44624 ZEND_NULL_HANDLER,
44625 ZEND_NULL_HANDLER,
44626 ZEND_NULL_HANDLER,
44627 ZEND_NULL_HANDLER,
44628 ZEND_NULL_HANDLER,
44629 ZEND_NULL_HANDLER,
44630 ZEND_NULL_HANDLER,
44631 ZEND_NULL_HANDLER,
44632 ZEND_NULL_HANDLER,
44633 ZEND_NULL_HANDLER,
44634 ZEND_NULL_HANDLER,
44635 ZEND_NULL_HANDLER,
44636 ZEND_NULL_HANDLER,
44637 ZEND_NULL_HANDLER,
44638 ZEND_NULL_HANDLER,
44639 ZEND_NULL_HANDLER,
44640 ZEND_NULL_HANDLER,
44641 ZEND_NULL_HANDLER,
44642 ZEND_NULL_HANDLER,
44643 ZEND_NULL_HANDLER,
44644 ZEND_NULL_HANDLER,
44645 ZEND_NULL_HANDLER,
44646 ZEND_NULL_HANDLER,
44647 ZEND_NULL_HANDLER,
44648 ZEND_NULL_HANDLER,
44649 ZEND_NULL_HANDLER,
44650 ZEND_NULL_HANDLER,
44651 ZEND_NULL_HANDLER,
44652 ZEND_NULL_HANDLER,
44653 ZEND_NULL_HANDLER,
44654 ZEND_NULL_HANDLER,
44655 ZEND_NULL_HANDLER,
44656 ZEND_NULL_HANDLER,
44657 ZEND_NULL_HANDLER,
44658 ZEND_NULL_HANDLER,
44659 ZEND_NULL_HANDLER,
44660 ZEND_NULL_HANDLER,
44661 ZEND_NULL_HANDLER,
44662 ZEND_NULL_HANDLER,
44663 ZEND_NULL_HANDLER,
44664 ZEND_NULL_HANDLER,
44665 ZEND_NULL_HANDLER,
44666 ZEND_NULL_HANDLER,
44667 ZEND_NULL_HANDLER,
44668 ZEND_NULL_HANDLER,
44669 ZEND_NULL_HANDLER,
44670 ZEND_NULL_HANDLER,
44671 ZEND_NULL_HANDLER,
44672 ZEND_NULL_HANDLER,
44673 ZEND_NULL_HANDLER,
44674 ZEND_NULL_HANDLER,
44675 ZEND_NULL_HANDLER,
44676 ZEND_NULL_HANDLER,
44677 ZEND_NULL_HANDLER,
44678 ZEND_NULL_HANDLER,
44679 ZEND_NULL_HANDLER,
44680 ZEND_NULL_HANDLER,
44681 ZEND_NULL_HANDLER,
44682 ZEND_NULL_HANDLER,
44683 ZEND_NULL_HANDLER,
44684 ZEND_NULL_HANDLER,
44685 ZEND_NULL_HANDLER,
44686 ZEND_NULL_HANDLER,
44687 ZEND_NULL_HANDLER,
44688 ZEND_NULL_HANDLER,
44689 ZEND_NULL_HANDLER,
44690 ZEND_NULL_HANDLER,
44691 ZEND_NULL_HANDLER,
44692 ZEND_NULL_HANDLER,
44693 ZEND_NULL_HANDLER,
44694 ZEND_NULL_HANDLER,
44695 ZEND_NULL_HANDLER,
44696 ZEND_NULL_HANDLER,
44697 ZEND_NULL_HANDLER,
44698 ZEND_NULL_HANDLER,
44699 ZEND_NULL_HANDLER,
44700 ZEND_NULL_HANDLER,
44701 ZEND_NULL_HANDLER,
44702 ZEND_NULL_HANDLER,
44703 ZEND_NULL_HANDLER,
44704 ZEND_NULL_HANDLER,
44705 ZEND_NULL_HANDLER,
44706 ZEND_NULL_HANDLER,
44707 ZEND_NULL_HANDLER,
44708 ZEND_NULL_HANDLER,
44709 ZEND_NULL_HANDLER,
44710 ZEND_NULL_HANDLER,
44711 ZEND_NULL_HANDLER,
44712 ZEND_NULL_HANDLER,
44713 ZEND_NULL_HANDLER,
44714 ZEND_NULL_HANDLER,
44715 ZEND_NULL_HANDLER,
44716 ZEND_NULL_HANDLER,
44717 ZEND_NULL_HANDLER,
44718 ZEND_NULL_HANDLER,
44719 ZEND_NULL_HANDLER,
44720 ZEND_NULL_HANDLER,
44721 ZEND_NULL_HANDLER,
44722 ZEND_NULL_HANDLER,
44723 ZEND_NULL_HANDLER,
44724 ZEND_NULL_HANDLER,
44725 ZEND_NULL_HANDLER,
44726 ZEND_NULL_HANDLER,
44727 ZEND_NULL_HANDLER,
44728 ZEND_NULL_HANDLER,
44729 ZEND_NULL_HANDLER,
44730 ZEND_NULL_HANDLER,
44731 ZEND_NULL_HANDLER,
44732 ZEND_NULL_HANDLER,
44733 ZEND_NULL_HANDLER,
44734 ZEND_NULL_HANDLER,
44735 ZEND_NULL_HANDLER,
44736 ZEND_NULL_HANDLER,
44737 ZEND_NULL_HANDLER,
44738 ZEND_NULL_HANDLER,
44739 ZEND_NULL_HANDLER,
44740 ZEND_NULL_HANDLER,
44741 ZEND_NULL_HANDLER,
44742 ZEND_NULL_HANDLER,
44743 ZEND_NULL_HANDLER,
44744 ZEND_NULL_HANDLER,
44745 ZEND_NULL_HANDLER,
44746 ZEND_NULL_HANDLER,
44747 ZEND_NULL_HANDLER,
44748 ZEND_NULL_HANDLER,
44749 ZEND_NULL_HANDLER,
44750 ZEND_NULL_HANDLER,
44751 ZEND_NULL_HANDLER,
44752 ZEND_NULL_HANDLER,
44753 ZEND_NULL_HANDLER,
44754 ZEND_NULL_HANDLER,
44755 ZEND_NULL_HANDLER,
44756 ZEND_NULL_HANDLER,
44757 ZEND_NULL_HANDLER,
44758 ZEND_NULL_HANDLER,
44759 ZEND_NULL_HANDLER,
44760 ZEND_NULL_HANDLER,
44761 ZEND_NULL_HANDLER,
44762 ZEND_NULL_HANDLER,
44763 ZEND_NULL_HANDLER,
44764 ZEND_NULL_HANDLER,
44765 ZEND_NULL_HANDLER,
44766 ZEND_NULL_HANDLER,
44767 ZEND_NULL_HANDLER,
44768 ZEND_NULL_HANDLER,
44769 ZEND_NULL_HANDLER,
44770 ZEND_NULL_HANDLER,
44771 ZEND_NULL_HANDLER,
44772 ZEND_NULL_HANDLER,
44773 ZEND_NULL_HANDLER,
44774 ZEND_NULL_HANDLER,
44775 ZEND_NULL_HANDLER,
44776 ZEND_NULL_HANDLER,
44777 ZEND_NULL_HANDLER,
44778 ZEND_NULL_HANDLER,
44779 ZEND_NULL_HANDLER,
44780 ZEND_NULL_HANDLER,
44781 ZEND_NULL_HANDLER,
44782 ZEND_NULL_HANDLER,
44783 ZEND_NULL_HANDLER,
44784 ZEND_NULL_HANDLER,
44785 ZEND_NULL_HANDLER,
44786 ZEND_NULL_HANDLER,
44787 ZEND_NULL_HANDLER,
44788 ZEND_NULL_HANDLER,
44789 ZEND_NULL_HANDLER,
44790 ZEND_NULL_HANDLER,
44791 ZEND_NULL_HANDLER,
44792 ZEND_NULL_HANDLER,
44793 ZEND_NULL_HANDLER,
44794 ZEND_NULL_HANDLER,
44795 ZEND_NULL_HANDLER,
44796 ZEND_NULL_HANDLER,
44797 ZEND_NULL_HANDLER,
44798 ZEND_NULL_HANDLER,
44799 ZEND_NULL_HANDLER,
44800 ZEND_NULL_HANDLER,
44801 ZEND_NULL_HANDLER,
44802 ZEND_NULL_HANDLER,
44803 ZEND_NULL_HANDLER,
44804 ZEND_NULL_HANDLER,
44805 ZEND_NULL_HANDLER,
44806 ZEND_NULL_HANDLER,
44807 ZEND_NULL_HANDLER,
44808 ZEND_NULL_HANDLER,
44809 ZEND_NULL_HANDLER,
44810 ZEND_NULL_HANDLER,
44811 ZEND_NULL_HANDLER,
44812 ZEND_NULL_HANDLER,
44813 ZEND_NULL_HANDLER,
44814 ZEND_NULL_HANDLER,
44815 ZEND_NULL_HANDLER,
44816 ZEND_NULL_HANDLER,
44817 ZEND_NULL_HANDLER,
44818 ZEND_NULL_HANDLER,
44819 ZEND_NULL_HANDLER,
44820 ZEND_NULL_HANDLER,
44821 ZEND_NULL_HANDLER,
44822 ZEND_NULL_HANDLER,
44823 ZEND_NULL_HANDLER,
44824 ZEND_NULL_HANDLER,
44825 ZEND_NULL_HANDLER,
44826 ZEND_NULL_HANDLER,
44827 ZEND_NULL_HANDLER,
44828 ZEND_NULL_HANDLER,
44829 ZEND_NULL_HANDLER,
44830 ZEND_NULL_HANDLER,
44831 ZEND_NULL_HANDLER,
44832 ZEND_NULL_HANDLER,
44833 ZEND_NULL_HANDLER,
44834 ZEND_NULL_HANDLER,
44835 ZEND_NULL_HANDLER,
44836 ZEND_NULL_HANDLER,
44837 ZEND_NULL_HANDLER,
44838 ZEND_NULL_HANDLER,
44839 ZEND_NULL_HANDLER,
44840 ZEND_NULL_HANDLER,
44841 ZEND_NULL_HANDLER,
44842 ZEND_NULL_HANDLER,
44843 ZEND_NULL_HANDLER,
44844 ZEND_NULL_HANDLER,
44845 ZEND_NULL_HANDLER,
44846 ZEND_NULL_HANDLER,
44847 ZEND_NULL_HANDLER,
44848 ZEND_NULL_HANDLER,
44849 ZEND_NULL_HANDLER,
44850 ZEND_NULL_HANDLER,
44851 ZEND_NULL_HANDLER,
44852 ZEND_NULL_HANDLER,
44853 ZEND_NULL_HANDLER,
44854 ZEND_NULL_HANDLER,
44855 ZEND_NULL_HANDLER,
44856 ZEND_NULL_HANDLER,
44857 ZEND_NULL_HANDLER,
44858 ZEND_NULL_HANDLER,
44859 ZEND_NULL_HANDLER,
44860 ZEND_NULL_HANDLER,
44861 ZEND_NULL_HANDLER,
44862 ZEND_NULL_HANDLER,
44863 ZEND_NULL_HANDLER,
44864 ZEND_NULL_HANDLER,
44865 ZEND_NULL_HANDLER,
44866 ZEND_NULL_HANDLER,
44867 ZEND_NULL_HANDLER,
44868 ZEND_NULL_HANDLER,
44869 ZEND_NULL_HANDLER,
44870 ZEND_NULL_HANDLER,
44871 ZEND_NULL_HANDLER,
44872 ZEND_NULL_HANDLER,
44873 ZEND_NULL_HANDLER,
44874 ZEND_NULL_HANDLER,
44875 ZEND_NULL_HANDLER,
44876 ZEND_NULL_HANDLER,
44877 ZEND_NULL_HANDLER,
44878 ZEND_NULL_HANDLER,
44879 ZEND_NULL_HANDLER,
44880 ZEND_NULL_HANDLER,
44881 ZEND_NULL_HANDLER,
44882 ZEND_NULL_HANDLER,
44883 ZEND_NULL_HANDLER,
44884 ZEND_NULL_HANDLER,
44885 ZEND_NULL_HANDLER,
44886 ZEND_NULL_HANDLER,
44887 ZEND_NULL_HANDLER,
44888 ZEND_NULL_HANDLER,
44889 ZEND_NULL_HANDLER,
44890 ZEND_NULL_HANDLER,
44891 ZEND_NULL_HANDLER,
44892 ZEND_NULL_HANDLER,
44893 ZEND_NULL_HANDLER,
44894 ZEND_NULL_HANDLER,
44895 ZEND_NULL_HANDLER,
44896 ZEND_NULL_HANDLER,
44897 ZEND_NULL_HANDLER,
44898 ZEND_NULL_HANDLER,
44899 ZEND_NULL_HANDLER,
44900 ZEND_NULL_HANDLER,
44901 ZEND_NULL_HANDLER,
44902 ZEND_NULL_HANDLER,
44903 ZEND_NULL_HANDLER,
44904 ZEND_NULL_HANDLER,
44905 ZEND_NULL_HANDLER,
44906 ZEND_NULL_HANDLER,
44907 ZEND_NULL_HANDLER,
44908 ZEND_NULL_HANDLER,
44909 ZEND_NULL_HANDLER,
44910 ZEND_NULL_HANDLER,
44911 ZEND_NULL_HANDLER,
44912 ZEND_NULL_HANDLER,
44913 ZEND_NULL_HANDLER,
44914 ZEND_NULL_HANDLER,
44915 ZEND_NULL_HANDLER,
44916 ZEND_NULL_HANDLER,
44917 ZEND_NULL_HANDLER,
44918 ZEND_NULL_HANDLER,
44919 ZEND_NULL_HANDLER,
44920 ZEND_NULL_HANDLER,
44921 ZEND_NULL_HANDLER,
44922 ZEND_NULL_HANDLER,
44923 ZEND_NULL_HANDLER,
44924 ZEND_NULL_HANDLER,
44925 ZEND_NULL_HANDLER,
44926 ZEND_NULL_HANDLER,
44927 ZEND_NULL_HANDLER,
44928 ZEND_NULL_HANDLER,
44929 ZEND_NULL_HANDLER,
44930 ZEND_NULL_HANDLER,
44931 ZEND_NULL_HANDLER,
44932 ZEND_NULL_HANDLER,
44933 ZEND_NULL_HANDLER,
44934 ZEND_NULL_HANDLER,
44935 ZEND_NULL_HANDLER,
44936 ZEND_NULL_HANDLER,
44937 ZEND_NULL_HANDLER,
44938 ZEND_NULL_HANDLER,
44939 ZEND_NULL_HANDLER,
44940 ZEND_NULL_HANDLER,
44941 ZEND_NULL_HANDLER,
44942 ZEND_NULL_HANDLER,
44943 ZEND_NULL_HANDLER,
44944 ZEND_NULL_HANDLER,
44945 ZEND_NULL_HANDLER,
44946 ZEND_NULL_HANDLER,
44947 ZEND_NULL_HANDLER,
44948 ZEND_NULL_HANDLER,
44949 ZEND_NULL_HANDLER,
44950 ZEND_NULL_HANDLER,
44951 ZEND_NULL_HANDLER,
44952 ZEND_NULL_HANDLER,
44953 ZEND_NULL_HANDLER,
44954 ZEND_NULL_HANDLER,
44955 ZEND_NULL_HANDLER,
44956 ZEND_NULL_HANDLER,
44957 ZEND_NULL_HANDLER,
44958 ZEND_NULL_HANDLER,
44959 ZEND_NULL_HANDLER,
44960 ZEND_NULL_HANDLER,
44961 ZEND_NULL_HANDLER,
44962 ZEND_NULL_HANDLER,
44963 ZEND_NULL_HANDLER,
44964 ZEND_NULL_HANDLER,
44965 ZEND_NULL_HANDLER,
44966 ZEND_NULL_HANDLER,
44967 ZEND_NULL_HANDLER,
44968 ZEND_NULL_HANDLER,
44969 ZEND_NULL_HANDLER,
44970 ZEND_NULL_HANDLER,
44971 ZEND_NULL_HANDLER,
44972 ZEND_NULL_HANDLER,
44973 ZEND_NULL_HANDLER,
44974 ZEND_NULL_HANDLER,
44975 ZEND_NULL_HANDLER,
44976 ZEND_NULL_HANDLER,
44977 ZEND_NULL_HANDLER,
44978 ZEND_NULL_HANDLER,
44979 ZEND_NULL_HANDLER,
44980 ZEND_NULL_HANDLER,
44981 ZEND_NULL_HANDLER,
44982 ZEND_NULL_HANDLER,
44983 ZEND_NULL_HANDLER,
44984 ZEND_NULL_HANDLER,
44985 ZEND_NULL_HANDLER,
44986 ZEND_NULL_HANDLER,
44987 ZEND_NULL_HANDLER,
44988 ZEND_NULL_HANDLER,
44989 ZEND_NULL_HANDLER,
44990 ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER,
44991 ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER,
44992 ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER,
44993 ZEND_NULL_HANDLER,
44994 ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER,
44995 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
44996 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER,
44997 ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER,
44998 ZEND_NULL_HANDLER,
44999 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
45000 ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER,
45001 ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER,
45002 ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER,
45003 ZEND_NULL_HANDLER,
45004 ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER,
45005 ZEND_NULL_HANDLER,
45006 ZEND_NULL_HANDLER,
45007 ZEND_NULL_HANDLER,
45008 ZEND_NULL_HANDLER,
45009 ZEND_NULL_HANDLER,
45010 ZEND_NULL_HANDLER,
45011 ZEND_NULL_HANDLER,
45012 ZEND_NULL_HANDLER,
45013 ZEND_NULL_HANDLER,
45014 ZEND_NULL_HANDLER,
45015 ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER,
45016 ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER,
45017 ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER,
45018 ZEND_NULL_HANDLER,
45019 ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER,
45020 ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER,
45021 ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER,
45022 ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER,
45023 ZEND_NULL_HANDLER,
45024 ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER,
45025 ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER,
45026 ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER,
45027 ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER,
45028 ZEND_NULL_HANDLER,
45029 ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER,
45030 ZEND_NULL_HANDLER,
45031 ZEND_NULL_HANDLER,
45032 ZEND_NULL_HANDLER,
45033 ZEND_NULL_HANDLER,
45034 ZEND_NULL_HANDLER,
45035 ZEND_NULL_HANDLER,
45036 ZEND_NULL_HANDLER,
45037 ZEND_NULL_HANDLER,
45038 ZEND_NULL_HANDLER,
45039 ZEND_NULL_HANDLER,
45040 ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER,
45041 ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER,
45042 ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER,
45043 ZEND_NULL_HANDLER,
45044 ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER,
45045 ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
45046 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER,
45047 ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER,
45048 ZEND_NULL_HANDLER,
45049 ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
45050 ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER,
45051 ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER,
45052 ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER,
45053 ZEND_NULL_HANDLER,
45054 ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER,
45055 ZEND_NULL_HANDLER,
45056 ZEND_NULL_HANDLER,
45057 ZEND_NULL_HANDLER,
45058 ZEND_NULL_HANDLER,
45059 ZEND_NULL_HANDLER,
45060 ZEND_NULL_HANDLER,
45061 ZEND_NULL_HANDLER,
45062 ZEND_NULL_HANDLER,
45063 ZEND_NULL_HANDLER,
45064 ZEND_NULL_HANDLER,
45065 ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER,
45066 ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER,
45067 ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER,
45068 ZEND_NULL_HANDLER,
45069 ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER,
45070 ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER,
45071 ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER,
45072 ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER,
45073 ZEND_NULL_HANDLER,
45074 ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER,
45075 ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER,
45076 ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER,
45077 ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER,
45078 ZEND_NULL_HANDLER,
45079 ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER,
45080 ZEND_NULL_HANDLER,
45081 ZEND_NULL_HANDLER,
45082 ZEND_NULL_HANDLER,
45083 ZEND_NULL_HANDLER,
45084 ZEND_NULL_HANDLER,
45085 ZEND_NULL_HANDLER,
45086 ZEND_NULL_HANDLER,
45087 ZEND_NULL_HANDLER,
45088 ZEND_NULL_HANDLER,
45089 ZEND_NULL_HANDLER,
45090 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER,
45091 ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER,
45092 ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER,
45093 ZEND_NULL_HANDLER,
45094 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER,
45095 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER,
45096 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER,
45097 ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER,
45098 ZEND_NULL_HANDLER,
45099 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER,
45100 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER,
45101 ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER,
45102 ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER,
45103 ZEND_NULL_HANDLER,
45104 ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER,
45105 ZEND_NULL_HANDLER,
45106 ZEND_NULL_HANDLER,
45107 ZEND_NULL_HANDLER,
45108 ZEND_NULL_HANDLER,
45109 ZEND_NULL_HANDLER,
45110 ZEND_NULL_HANDLER,
45111 ZEND_NULL_HANDLER,
45112 ZEND_NULL_HANDLER,
45113 ZEND_NULL_HANDLER,
45114 ZEND_NULL_HANDLER,
45115 ZEND_NULL_HANDLER,
45116 ZEND_NULL_HANDLER,
45117 ZEND_NULL_HANDLER,
45118 ZEND_NULL_HANDLER,
45119 ZEND_NULL_HANDLER,
45120 ZEND_NULL_HANDLER,
45121 ZEND_NULL_HANDLER,
45122 ZEND_NULL_HANDLER,
45123 ZEND_NULL_HANDLER,
45124 ZEND_NULL_HANDLER,
45125 ZEND_NULL_HANDLER,
45126 ZEND_NULL_HANDLER,
45127 ZEND_NULL_HANDLER,
45128 ZEND_NULL_HANDLER,
45129 ZEND_NULL_HANDLER,
45130 ZEND_NULL_HANDLER,
45131 ZEND_NULL_HANDLER,
45132 ZEND_NULL_HANDLER,
45133 ZEND_NULL_HANDLER,
45134 ZEND_NULL_HANDLER,
45135 ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
45136 ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
45137 ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
45138 ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
45139 ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
45140 ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
45141 ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
45142 ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
45143 ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
45144 ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
45145 ZEND_NULL_HANDLER,
45146 ZEND_NULL_HANDLER,
45147 ZEND_NULL_HANDLER,
45148 ZEND_NULL_HANDLER,
45149 ZEND_NULL_HANDLER,
45150 ZEND_INSTANCEOF_SPEC_CV_HANDLER,
45151 ZEND_INSTANCEOF_SPEC_CV_HANDLER,
45152 ZEND_INSTANCEOF_SPEC_CV_HANDLER,
45153 ZEND_INSTANCEOF_SPEC_CV_HANDLER,
45154 ZEND_INSTANCEOF_SPEC_CV_HANDLER,
45155 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45156 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45157 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45158 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45159 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45160 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45161 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45162 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45163 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45164 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45165 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45166 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45167 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45168 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45169 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45170 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45171 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45172 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45173 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45174 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45175 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45176 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45177 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45178 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45179 ZEND_DECLARE_CLASS_SPEC_HANDLER,
45180 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45181 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45182 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45183 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45184 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45185 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45186 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45187 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45188 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45189 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45190 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45191 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45192 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45193 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45194 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45195 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45196 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45197 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45198 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45199 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45200 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45201 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45202 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45203 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45204 ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
45205 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45206 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45207 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45208 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45209 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45210 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45211 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45212 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45213 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45214 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45215 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45216 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45217 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45218 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45219 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45220 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45221 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45222 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45223 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45224 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45225 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45226 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45227 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45228 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45229 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
45230 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45231 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45232 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45233 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45234 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45235 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45236 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45237 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45238 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45239 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45240 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45241 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45242 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45243 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45244 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45245 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45246 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45247 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45248 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45249 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45250 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45251 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45252 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45253 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45254 ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
45255 ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER,
45256 ZEND_NULL_HANDLER,
45257 ZEND_NULL_HANDLER,
45258 ZEND_NULL_HANDLER,
45259 ZEND_NULL_HANDLER,
45260 ZEND_NULL_HANDLER,
45261 ZEND_NULL_HANDLER,
45262 ZEND_NULL_HANDLER,
45263 ZEND_NULL_HANDLER,
45264 ZEND_NULL_HANDLER,
45265 ZEND_NULL_HANDLER,
45266 ZEND_NULL_HANDLER,
45267 ZEND_NULL_HANDLER,
45268 ZEND_NULL_HANDLER,
45269 ZEND_NULL_HANDLER,
45270 ZEND_NULL_HANDLER,
45271 ZEND_NULL_HANDLER,
45272 ZEND_NULL_HANDLER,
45273 ZEND_NULL_HANDLER,
45274 ZEND_NULL_HANDLER,
45275 ZEND_NULL_HANDLER,
45276 ZEND_NULL_HANDLER,
45277 ZEND_NULL_HANDLER,
45278 ZEND_NULL_HANDLER,
45279 ZEND_NULL_HANDLER,
45280 ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
45281 ZEND_NULL_HANDLER,
45282 ZEND_NULL_HANDLER,
45283 ZEND_NULL_HANDLER,
45284 ZEND_NULL_HANDLER,
45285 ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
45286 ZEND_NULL_HANDLER,
45287 ZEND_NULL_HANDLER,
45288 ZEND_NULL_HANDLER,
45289 ZEND_NULL_HANDLER,
45290 ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
45291 ZEND_NULL_HANDLER,
45292 ZEND_NULL_HANDLER,
45293 ZEND_NULL_HANDLER,
45294 ZEND_NULL_HANDLER,
45295 ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
45296 ZEND_NULL_HANDLER,
45297 ZEND_NULL_HANDLER,
45298 ZEND_NULL_HANDLER,
45299 ZEND_NULL_HANDLER,
45300 ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
45301 ZEND_NULL_HANDLER,
45302 ZEND_NULL_HANDLER,
45303 ZEND_NULL_HANDLER,
45304 ZEND_NULL_HANDLER,
45305 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45306 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45307 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45308 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45309 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45310 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45311 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45312 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45313 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45314 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45315 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45316 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45317 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45318 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45319 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45320 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45321 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45322 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45323 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45324 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45325 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45326 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45327 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45328 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45329 ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45330 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45331 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45332 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45333 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45334 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45335 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45336 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45337 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45338 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45339 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45340 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45341 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45342 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45343 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45344 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45345 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45346 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45347 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45348 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45349 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45350 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45351 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45352 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45353 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45354 ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45355 ZEND_NULL_HANDLER,
45356 ZEND_NULL_HANDLER,
45357 ZEND_NULL_HANDLER,
45358 ZEND_NULL_HANDLER,
45359 ZEND_NULL_HANDLER,
45360 ZEND_NULL_HANDLER,
45361 ZEND_NULL_HANDLER,
45362 ZEND_NULL_HANDLER,
45363 ZEND_NULL_HANDLER,
45364 ZEND_NULL_HANDLER,
45365 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER,
45366 ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER,
45367 ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER,
45368 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER,
45369 ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER,
45370 ZEND_NULL_HANDLER,
45371 ZEND_NULL_HANDLER,
45372 ZEND_NULL_HANDLER,
45373 ZEND_NULL_HANDLER,
45374 ZEND_NULL_HANDLER,
45375 ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER,
45376 ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER,
45377 ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER,
45378 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER,
45379 ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER,
45380 ZEND_NULL_HANDLER,
45381 ZEND_NULL_HANDLER,
45382 ZEND_NULL_HANDLER,
45383 ZEND_NULL_HANDLER,
45384 ZEND_NULL_HANDLER,
45385 ZEND_NULL_HANDLER,
45386 ZEND_NULL_HANDLER,
45387 ZEND_NULL_HANDLER,
45388 ZEND_NULL_HANDLER,
45389 ZEND_NULL_HANDLER,
45390 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER,
45391 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER,
45392 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER,
45393 ZEND_NULL_HANDLER,
45394 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER,
45395 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER,
45396 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER,
45397 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER,
45398 ZEND_NULL_HANDLER,
45399 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER,
45400 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER,
45401 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER,
45402 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER,
45403 ZEND_NULL_HANDLER,
45404 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
45405 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45406 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45407 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45408 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45409 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45410 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45411 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45412 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45413 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45414 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45415 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45416 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45417 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45418 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45419 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45420 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45421 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45422 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45423 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45424 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45425 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45426 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45427 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45428 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45429 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45430 ZEND_USER_OPCODE_SPEC_HANDLER,
45431 ZEND_USER_OPCODE_SPEC_HANDLER,
45432 ZEND_USER_OPCODE_SPEC_HANDLER,
45433 ZEND_USER_OPCODE_SPEC_HANDLER,
45434 ZEND_USER_OPCODE_SPEC_HANDLER,
45435 ZEND_USER_OPCODE_SPEC_HANDLER,
45436 ZEND_USER_OPCODE_SPEC_HANDLER,
45437 ZEND_USER_OPCODE_SPEC_HANDLER,
45438 ZEND_USER_OPCODE_SPEC_HANDLER,
45439 ZEND_USER_OPCODE_SPEC_HANDLER,
45440 ZEND_USER_OPCODE_SPEC_HANDLER,
45441 ZEND_USER_OPCODE_SPEC_HANDLER,
45442 ZEND_USER_OPCODE_SPEC_HANDLER,
45443 ZEND_USER_OPCODE_SPEC_HANDLER,
45444 ZEND_USER_OPCODE_SPEC_HANDLER,
45445 ZEND_USER_OPCODE_SPEC_HANDLER,
45446 ZEND_USER_OPCODE_SPEC_HANDLER,
45447 ZEND_USER_OPCODE_SPEC_HANDLER,
45448 ZEND_USER_OPCODE_SPEC_HANDLER,
45449 ZEND_USER_OPCODE_SPEC_HANDLER,
45450 ZEND_USER_OPCODE_SPEC_HANDLER,
45451 ZEND_USER_OPCODE_SPEC_HANDLER,
45452 ZEND_USER_OPCODE_SPEC_HANDLER,
45453 ZEND_USER_OPCODE_SPEC_HANDLER,
45454 ZEND_USER_OPCODE_SPEC_HANDLER,
45455 ZEND_NULL_HANDLER,
45456 ZEND_NULL_HANDLER,
45457 ZEND_NULL_HANDLER,
45458 ZEND_NULL_HANDLER,
45459 ZEND_NULL_HANDLER,
45460 ZEND_NULL_HANDLER,
45461 ZEND_NULL_HANDLER,
45462 ZEND_NULL_HANDLER,
45463 ZEND_NULL_HANDLER,
45464 ZEND_NULL_HANDLER,
45465 ZEND_NULL_HANDLER,
45466 ZEND_NULL_HANDLER,
45467 ZEND_NULL_HANDLER,
45468 ZEND_NULL_HANDLER,
45469 ZEND_NULL_HANDLER,
45470 ZEND_NULL_HANDLER,
45471 ZEND_NULL_HANDLER,
45472 ZEND_NULL_HANDLER,
45473 ZEND_NULL_HANDLER,
45474 ZEND_NULL_HANDLER,
45475 ZEND_NULL_HANDLER,
45476 ZEND_NULL_HANDLER,
45477 ZEND_NULL_HANDLER,
45478 ZEND_NULL_HANDLER,
45479 ZEND_NULL_HANDLER,
45480 ZEND_JMP_SET_SPEC_CONST_HANDLER,
45481 ZEND_JMP_SET_SPEC_CONST_HANDLER,
45482 ZEND_JMP_SET_SPEC_CONST_HANDLER,
45483 ZEND_JMP_SET_SPEC_CONST_HANDLER,
45484 ZEND_JMP_SET_SPEC_CONST_HANDLER,
45485 ZEND_JMP_SET_SPEC_TMP_HANDLER,
45486 ZEND_JMP_SET_SPEC_TMP_HANDLER,
45487 ZEND_JMP_SET_SPEC_TMP_HANDLER,
45488 ZEND_JMP_SET_SPEC_TMP_HANDLER,
45489 ZEND_JMP_SET_SPEC_TMP_HANDLER,
45490 ZEND_JMP_SET_SPEC_VAR_HANDLER,
45491 ZEND_JMP_SET_SPEC_VAR_HANDLER,
45492 ZEND_JMP_SET_SPEC_VAR_HANDLER,
45493 ZEND_JMP_SET_SPEC_VAR_HANDLER,
45494 ZEND_JMP_SET_SPEC_VAR_HANDLER,
45495 ZEND_NULL_HANDLER,
45496 ZEND_NULL_HANDLER,
45497 ZEND_NULL_HANDLER,
45498 ZEND_NULL_HANDLER,
45499 ZEND_NULL_HANDLER,
45500 ZEND_JMP_SET_SPEC_CV_HANDLER,
45501 ZEND_JMP_SET_SPEC_CV_HANDLER,
45502 ZEND_JMP_SET_SPEC_CV_HANDLER,
45503 ZEND_JMP_SET_SPEC_CV_HANDLER,
45504 ZEND_JMP_SET_SPEC_CV_HANDLER,
45505 ZEND_NULL_HANDLER,
45506 ZEND_NULL_HANDLER,
45507 ZEND_NULL_HANDLER,
45508 ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER,
45509 ZEND_NULL_HANDLER,
45510 ZEND_NULL_HANDLER,
45511 ZEND_NULL_HANDLER,
45512 ZEND_NULL_HANDLER,
45513 ZEND_NULL_HANDLER,
45514 ZEND_NULL_HANDLER,
45515 ZEND_NULL_HANDLER,
45516 ZEND_NULL_HANDLER,
45517 ZEND_NULL_HANDLER,
45518 ZEND_NULL_HANDLER,
45519 ZEND_NULL_HANDLER,
45520 ZEND_NULL_HANDLER,
45521 ZEND_NULL_HANDLER,
45522 ZEND_NULL_HANDLER,
45523 ZEND_NULL_HANDLER,
45524 ZEND_NULL_HANDLER,
45525 ZEND_NULL_HANDLER,
45526 ZEND_NULL_HANDLER,
45527 ZEND_NULL_HANDLER,
45528 ZEND_NULL_HANDLER,
45529 ZEND_NULL_HANDLER,
45530 ZEND_ADD_TRAIT_SPEC_HANDLER,
45531 ZEND_ADD_TRAIT_SPEC_HANDLER,
45532 ZEND_ADD_TRAIT_SPEC_HANDLER,
45533 ZEND_ADD_TRAIT_SPEC_HANDLER,
45534 ZEND_ADD_TRAIT_SPEC_HANDLER,
45535 ZEND_ADD_TRAIT_SPEC_HANDLER,
45536 ZEND_ADD_TRAIT_SPEC_HANDLER,
45537 ZEND_ADD_TRAIT_SPEC_HANDLER,
45538 ZEND_ADD_TRAIT_SPEC_HANDLER,
45539 ZEND_ADD_TRAIT_SPEC_HANDLER,
45540 ZEND_ADD_TRAIT_SPEC_HANDLER,
45541 ZEND_ADD_TRAIT_SPEC_HANDLER,
45542 ZEND_ADD_TRAIT_SPEC_HANDLER,
45543 ZEND_ADD_TRAIT_SPEC_HANDLER,
45544 ZEND_ADD_TRAIT_SPEC_HANDLER,
45545 ZEND_ADD_TRAIT_SPEC_HANDLER,
45546 ZEND_ADD_TRAIT_SPEC_HANDLER,
45547 ZEND_ADD_TRAIT_SPEC_HANDLER,
45548 ZEND_ADD_TRAIT_SPEC_HANDLER,
45549 ZEND_ADD_TRAIT_SPEC_HANDLER,
45550 ZEND_ADD_TRAIT_SPEC_HANDLER,
45551 ZEND_ADD_TRAIT_SPEC_HANDLER,
45552 ZEND_ADD_TRAIT_SPEC_HANDLER,
45553 ZEND_ADD_TRAIT_SPEC_HANDLER,
45554 ZEND_ADD_TRAIT_SPEC_HANDLER,
45555 ZEND_BIND_TRAITS_SPEC_HANDLER,
45556 ZEND_BIND_TRAITS_SPEC_HANDLER,
45557 ZEND_BIND_TRAITS_SPEC_HANDLER,
45558 ZEND_BIND_TRAITS_SPEC_HANDLER,
45559 ZEND_BIND_TRAITS_SPEC_HANDLER,
45560 ZEND_BIND_TRAITS_SPEC_HANDLER,
45561 ZEND_BIND_TRAITS_SPEC_HANDLER,
45562 ZEND_BIND_TRAITS_SPEC_HANDLER,
45563 ZEND_BIND_TRAITS_SPEC_HANDLER,
45564 ZEND_BIND_TRAITS_SPEC_HANDLER,
45565 ZEND_BIND_TRAITS_SPEC_HANDLER,
45566 ZEND_BIND_TRAITS_SPEC_HANDLER,
45567 ZEND_BIND_TRAITS_SPEC_HANDLER,
45568 ZEND_BIND_TRAITS_SPEC_HANDLER,
45569 ZEND_BIND_TRAITS_SPEC_HANDLER,
45570 ZEND_BIND_TRAITS_SPEC_HANDLER,
45571 ZEND_BIND_TRAITS_SPEC_HANDLER,
45572 ZEND_BIND_TRAITS_SPEC_HANDLER,
45573 ZEND_BIND_TRAITS_SPEC_HANDLER,
45574 ZEND_BIND_TRAITS_SPEC_HANDLER,
45575 ZEND_BIND_TRAITS_SPEC_HANDLER,
45576 ZEND_BIND_TRAITS_SPEC_HANDLER,
45577 ZEND_BIND_TRAITS_SPEC_HANDLER,
45578 ZEND_BIND_TRAITS_SPEC_HANDLER,
45579 ZEND_BIND_TRAITS_SPEC_HANDLER,
45580 ZEND_NULL_HANDLER,
45581 ZEND_NULL_HANDLER,
45582 ZEND_NULL_HANDLER,
45583 ZEND_NULL_HANDLER,
45584 ZEND_NULL_HANDLER,
45585 ZEND_NULL_HANDLER,
45586 ZEND_NULL_HANDLER,
45587 ZEND_NULL_HANDLER,
45588 ZEND_NULL_HANDLER,
45589 ZEND_NULL_HANDLER,
45590 ZEND_NULL_HANDLER,
45591 ZEND_NULL_HANDLER,
45592 ZEND_NULL_HANDLER,
45593 ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER,
45594 ZEND_NULL_HANDLER,
45595 ZEND_NULL_HANDLER,
45596 ZEND_NULL_HANDLER,
45597 ZEND_NULL_HANDLER,
45598 ZEND_NULL_HANDLER,
45599 ZEND_NULL_HANDLER,
45600 ZEND_NULL_HANDLER,
45601 ZEND_NULL_HANDLER,
45602 ZEND_NULL_HANDLER,
45603 ZEND_NULL_HANDLER,
45604 ZEND_NULL_HANDLER,
45605 ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
45606 ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
45607 ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
45608 ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
45609 ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
45610 ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
45611 ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
45612 ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
45613 ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
45614 ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
45615 ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
45616 ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
45617 ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
45618 ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
45619 ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
45620 ZEND_NULL_HANDLER,
45621 ZEND_NULL_HANDLER,
45622 ZEND_NULL_HANDLER,
45623 ZEND_NULL_HANDLER,
45624 ZEND_NULL_HANDLER,
45625 ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
45626 ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
45627 ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
45628 ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
45629 ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
45630 ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
45631 ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
45632 ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
45633 ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
45634 ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
45635 ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
45636 ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
45637 ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
45638 ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
45639 ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
45640 ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
45641 ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
45642 ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
45643 ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
45644 ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
45645 ZEND_NULL_HANDLER,
45646 ZEND_NULL_HANDLER,
45647 ZEND_NULL_HANDLER,
45648 ZEND_NULL_HANDLER,
45649 ZEND_NULL_HANDLER,
45650 ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
45651 ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
45652 ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
45653 ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
45654 ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
45655 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45656 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45657 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45658 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45659 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45660 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45661 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45662 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45663 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45664 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45665 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45666 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45667 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45668 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45669 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45670 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45671 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45672 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45673 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45674 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45675 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45676 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45677 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45678 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45679 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45680 ZEND_YIELD_SPEC_CONST_CONST_HANDLER,
45681 ZEND_YIELD_SPEC_CONST_TMP_HANDLER,
45682 ZEND_YIELD_SPEC_CONST_VAR_HANDLER,
45683 ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER,
45684 ZEND_YIELD_SPEC_CONST_CV_HANDLER,
45685 ZEND_YIELD_SPEC_TMP_CONST_HANDLER,
45686 ZEND_YIELD_SPEC_TMP_TMP_HANDLER,
45687 ZEND_YIELD_SPEC_TMP_VAR_HANDLER,
45688 ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER,
45689 ZEND_YIELD_SPEC_TMP_CV_HANDLER,
45690 ZEND_YIELD_SPEC_VAR_CONST_HANDLER,
45691 ZEND_YIELD_SPEC_VAR_TMP_HANDLER,
45692 ZEND_YIELD_SPEC_VAR_VAR_HANDLER,
45693 ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER,
45694 ZEND_YIELD_SPEC_VAR_CV_HANDLER,
45695 ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER,
45696 ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER,
45697 ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER,
45698 ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER,
45699 ZEND_YIELD_SPEC_UNUSED_CV_HANDLER,
45700 ZEND_YIELD_SPEC_CV_CONST_HANDLER,
45701 ZEND_YIELD_SPEC_CV_TMP_HANDLER,
45702 ZEND_YIELD_SPEC_CV_VAR_HANDLER,
45703 ZEND_YIELD_SPEC_CV_UNUSED_HANDLER,
45704 ZEND_YIELD_SPEC_CV_CV_HANDLER,
45705 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45706 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45707 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45708 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45709 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45710 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45711 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45712 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45713 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45714 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45715 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45716 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45717 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45718 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45719 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45720 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45721 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45722 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45723 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45724 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45725 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45726 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45727 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45728 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45729 ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45730 ZEND_FAST_CALL_SPEC_HANDLER,
45731 ZEND_FAST_CALL_SPEC_HANDLER,
45732 ZEND_FAST_CALL_SPEC_HANDLER,
45733 ZEND_FAST_CALL_SPEC_HANDLER,
45734 ZEND_FAST_CALL_SPEC_HANDLER,
45735 ZEND_FAST_CALL_SPEC_HANDLER,
45736 ZEND_FAST_CALL_SPEC_HANDLER,
45737 ZEND_FAST_CALL_SPEC_HANDLER,
45738 ZEND_FAST_CALL_SPEC_HANDLER,
45739 ZEND_FAST_CALL_SPEC_HANDLER,
45740 ZEND_FAST_CALL_SPEC_HANDLER,
45741 ZEND_FAST_CALL_SPEC_HANDLER,
45742 ZEND_FAST_CALL_SPEC_HANDLER,
45743 ZEND_FAST_CALL_SPEC_HANDLER,
45744 ZEND_FAST_CALL_SPEC_HANDLER,
45745 ZEND_FAST_CALL_SPEC_HANDLER,
45746 ZEND_FAST_CALL_SPEC_HANDLER,
45747 ZEND_FAST_CALL_SPEC_HANDLER,
45748 ZEND_FAST_CALL_SPEC_HANDLER,
45749 ZEND_FAST_CALL_SPEC_HANDLER,
45750 ZEND_FAST_CALL_SPEC_HANDLER,
45751 ZEND_FAST_CALL_SPEC_HANDLER,
45752 ZEND_FAST_CALL_SPEC_HANDLER,
45753 ZEND_FAST_CALL_SPEC_HANDLER,
45754 ZEND_FAST_CALL_SPEC_HANDLER,
45755 ZEND_FAST_RET_SPEC_HANDLER,
45756 ZEND_FAST_RET_SPEC_HANDLER,
45757 ZEND_FAST_RET_SPEC_HANDLER,
45758 ZEND_FAST_RET_SPEC_HANDLER,
45759 ZEND_FAST_RET_SPEC_HANDLER,
45760 ZEND_FAST_RET_SPEC_HANDLER,
45761 ZEND_FAST_RET_SPEC_HANDLER,
45762 ZEND_FAST_RET_SPEC_HANDLER,
45763 ZEND_FAST_RET_SPEC_HANDLER,
45764 ZEND_FAST_RET_SPEC_HANDLER,
45765 ZEND_FAST_RET_SPEC_HANDLER,
45766 ZEND_FAST_RET_SPEC_HANDLER,
45767 ZEND_FAST_RET_SPEC_HANDLER,
45768 ZEND_FAST_RET_SPEC_HANDLER,
45769 ZEND_FAST_RET_SPEC_HANDLER,
45770 ZEND_FAST_RET_SPEC_HANDLER,
45771 ZEND_FAST_RET_SPEC_HANDLER,
45772 ZEND_FAST_RET_SPEC_HANDLER,
45773 ZEND_FAST_RET_SPEC_HANDLER,
45774 ZEND_FAST_RET_SPEC_HANDLER,
45775 ZEND_FAST_RET_SPEC_HANDLER,
45776 ZEND_FAST_RET_SPEC_HANDLER,
45777 ZEND_FAST_RET_SPEC_HANDLER,
45778 ZEND_FAST_RET_SPEC_HANDLER,
45779 ZEND_FAST_RET_SPEC_HANDLER,
45780 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45781 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45782 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45783 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45784 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45785 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45786 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45787 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45788 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45789 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45790 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45791 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45792 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45793 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45794 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45795 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45796 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45797 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45798 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45799 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45800 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45801 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45802 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45803 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45804 ZEND_RECV_VARIADIC_SPEC_HANDLER,
45805 ZEND_SEND_UNPACK_SPEC_HANDLER,
45806 ZEND_SEND_UNPACK_SPEC_HANDLER,
45807 ZEND_SEND_UNPACK_SPEC_HANDLER,
45808 ZEND_SEND_UNPACK_SPEC_HANDLER,
45809 ZEND_SEND_UNPACK_SPEC_HANDLER,
45810 ZEND_SEND_UNPACK_SPEC_HANDLER,
45811 ZEND_SEND_UNPACK_SPEC_HANDLER,
45812 ZEND_SEND_UNPACK_SPEC_HANDLER,
45813 ZEND_SEND_UNPACK_SPEC_HANDLER,
45814 ZEND_SEND_UNPACK_SPEC_HANDLER,
45815 ZEND_SEND_UNPACK_SPEC_HANDLER,
45816 ZEND_SEND_UNPACK_SPEC_HANDLER,
45817 ZEND_SEND_UNPACK_SPEC_HANDLER,
45818 ZEND_SEND_UNPACK_SPEC_HANDLER,
45819 ZEND_SEND_UNPACK_SPEC_HANDLER,
45820 ZEND_SEND_UNPACK_SPEC_HANDLER,
45821 ZEND_SEND_UNPACK_SPEC_HANDLER,
45822 ZEND_SEND_UNPACK_SPEC_HANDLER,
45823 ZEND_SEND_UNPACK_SPEC_HANDLER,
45824 ZEND_SEND_UNPACK_SPEC_HANDLER,
45825 ZEND_SEND_UNPACK_SPEC_HANDLER,
45826 ZEND_SEND_UNPACK_SPEC_HANDLER,
45827 ZEND_SEND_UNPACK_SPEC_HANDLER,
45828 ZEND_SEND_UNPACK_SPEC_HANDLER,
45829 ZEND_SEND_UNPACK_SPEC_HANDLER,
45830 ZEND_POW_SPEC_CONST_CONST_HANDLER,
45831 ZEND_POW_SPEC_CONST_TMP_HANDLER,
45832 ZEND_POW_SPEC_CONST_VAR_HANDLER,
45833 ZEND_NULL_HANDLER,
45834 ZEND_POW_SPEC_CONST_CV_HANDLER,
45835 ZEND_POW_SPEC_TMP_CONST_HANDLER,
45836 ZEND_POW_SPEC_TMP_TMP_HANDLER,
45837 ZEND_POW_SPEC_TMP_VAR_HANDLER,
45838 ZEND_NULL_HANDLER,
45839 ZEND_POW_SPEC_TMP_CV_HANDLER,
45840 ZEND_POW_SPEC_VAR_CONST_HANDLER,
45841 ZEND_POW_SPEC_VAR_TMP_HANDLER,
45842 ZEND_POW_SPEC_VAR_VAR_HANDLER,
45843 ZEND_NULL_HANDLER,
45844 ZEND_POW_SPEC_VAR_CV_HANDLER,
45845 ZEND_NULL_HANDLER,
45846 ZEND_NULL_HANDLER,
45847 ZEND_NULL_HANDLER,
45848 ZEND_NULL_HANDLER,
45849 ZEND_NULL_HANDLER,
45850 ZEND_POW_SPEC_CV_CONST_HANDLER,
45851 ZEND_POW_SPEC_CV_TMP_HANDLER,
45852 ZEND_POW_SPEC_CV_VAR_HANDLER,
45853 ZEND_NULL_HANDLER,
45854 ZEND_POW_SPEC_CV_CV_HANDLER,
45855 ZEND_NULL_HANDLER,
45856 ZEND_NULL_HANDLER,
45857 ZEND_NULL_HANDLER,
45858 ZEND_NULL_HANDLER,
45859 ZEND_NULL_HANDLER,
45860 ZEND_NULL_HANDLER,
45861 ZEND_NULL_HANDLER,
45862 ZEND_NULL_HANDLER,
45863 ZEND_NULL_HANDLER,
45864 ZEND_NULL_HANDLER,
45865 ZEND_ASSIGN_POW_SPEC_VAR_CONST_HANDLER,
45866 ZEND_ASSIGN_POW_SPEC_VAR_TMP_HANDLER,
45867 ZEND_ASSIGN_POW_SPEC_VAR_VAR_HANDLER,
45868 ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_HANDLER,
45869 ZEND_ASSIGN_POW_SPEC_VAR_CV_HANDLER,
45870 ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_HANDLER,
45871 ZEND_ASSIGN_POW_SPEC_UNUSED_TMP_HANDLER,
45872 ZEND_ASSIGN_POW_SPEC_UNUSED_VAR_HANDLER,
45873 ZEND_ASSIGN_POW_SPEC_UNUSED_UNUSED_HANDLER,
45874 ZEND_ASSIGN_POW_SPEC_UNUSED_CV_HANDLER,
45875 ZEND_ASSIGN_POW_SPEC_CV_CONST_HANDLER,
45876 ZEND_ASSIGN_POW_SPEC_CV_TMP_HANDLER,
45877 ZEND_ASSIGN_POW_SPEC_CV_VAR_HANDLER,
45878 ZEND_ASSIGN_POW_SPEC_CV_UNUSED_HANDLER,
45879 ZEND_ASSIGN_POW_SPEC_CV_CV_HANDLER,
45880 ZEND_NULL_HANDLER
45881 };
45882 zend_opcode_handlers = (opcode_handler_t*)labels;
45883 }
zend_vm_get_opcode_handler(zend_uchar opcode,zend_op * op)45884 static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op)
45885 {
45886 static const int zend_vm_decode[] = {
45887 _UNUSED_CODE, /* 0 */
45888 _CONST_CODE, /* 1 = IS_CONST */
45889 _TMP_CODE, /* 2 = IS_TMP_VAR */
45890 _UNUSED_CODE, /* 3 */
45891 _VAR_CODE, /* 4 = IS_VAR */
45892 _UNUSED_CODE, /* 5 */
45893 _UNUSED_CODE, /* 6 */
45894 _UNUSED_CODE, /* 7 */
45895 _UNUSED_CODE, /* 8 = IS_UNUSED */
45896 _UNUSED_CODE, /* 9 */
45897 _UNUSED_CODE, /* 10 */
45898 _UNUSED_CODE, /* 11 */
45899 _UNUSED_CODE, /* 12 */
45900 _UNUSED_CODE, /* 13 */
45901 _UNUSED_CODE, /* 14 */
45902 _UNUSED_CODE, /* 15 */
45903 _CV_CODE /* 16 = IS_CV */
45904 };
45905 return zend_opcode_handlers[opcode * 25 + zend_vm_decode[op->op1_type] * 5 + zend_vm_decode[op->op2_type]];
45906 }
45907
zend_vm_set_opcode_handler(zend_op * op)45908 ZEND_API void zend_vm_set_opcode_handler(zend_op* op)
45909 {
45910 op->handler = zend_vm_get_opcode_handler(zend_user_opcodes[op->opcode], op);
45911 }
45912
zend_do_fcall(ZEND_OPCODE_HANDLER_ARGS)45913 ZEND_API int zend_do_fcall(ZEND_OPCODE_HANDLER_ARGS)
45914 {
45915 return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
45916 }
45917
45918
