This source file includes following definitions.
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HELPER_EX
- ZEND_VM_HELPER_EX
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HELPER_EX
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HELPER_EX
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HELPER_EX
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HELPER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HELPER
- ZEND_VM_HELPER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HELPER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HELPER_EX
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HANDLER
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
29 {
30 USE_OPLINE
31 zend_free_op free_op1, free_op2;
32
33 SAVE_OPLINE();
34 fast_add_function(&EX_T(opline->result.var).tmp_var,
35 GET_OP1_ZVAL_PTR(BP_VAR_R),
36 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
37 FREE_OP1();
38 FREE_OP2();
39 CHECK_EXCEPTION();
40 ZEND_VM_NEXT_OPCODE();
41 }
42
43 ZEND_VM_HANDLER(2, ZEND_SUB, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
44 {
45 USE_OPLINE
46 zend_free_op free_op1, free_op2;
47
48 SAVE_OPLINE();
49 fast_sub_function(&EX_T(opline->result.var).tmp_var,
50 GET_OP1_ZVAL_PTR(BP_VAR_R),
51 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
52 FREE_OP1();
53 FREE_OP2();
54 CHECK_EXCEPTION();
55 ZEND_VM_NEXT_OPCODE();
56 }
57
58 ZEND_VM_HANDLER(3, ZEND_MUL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
59 {
60 USE_OPLINE
61 zend_free_op free_op1, free_op2;
62
63 SAVE_OPLINE();
64 fast_mul_function(&EX_T(opline->result.var).tmp_var,
65 GET_OP1_ZVAL_PTR(BP_VAR_R),
66 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
67 FREE_OP1();
68 FREE_OP2();
69 CHECK_EXCEPTION();
70 ZEND_VM_NEXT_OPCODE();
71 }
72
73 ZEND_VM_HANDLER(4, ZEND_DIV, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
74 {
75 USE_OPLINE
76 zend_free_op free_op1, free_op2;
77
78 SAVE_OPLINE();
79 fast_div_function(&EX_T(opline->result.var).tmp_var,
80 GET_OP1_ZVAL_PTR(BP_VAR_R),
81 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
82 FREE_OP1();
83 FREE_OP2();
84 CHECK_EXCEPTION();
85 ZEND_VM_NEXT_OPCODE();
86 }
87
88 ZEND_VM_HANDLER(5, ZEND_MOD, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
89 {
90 USE_OPLINE
91 zend_free_op free_op1, free_op2;
92
93 SAVE_OPLINE();
94 fast_mod_function(&EX_T(opline->result.var).tmp_var,
95 GET_OP1_ZVAL_PTR(BP_VAR_R),
96 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
97 FREE_OP1();
98 FREE_OP2();
99 CHECK_EXCEPTION();
100 ZEND_VM_NEXT_OPCODE();
101 }
102
103 ZEND_VM_HANDLER(6, ZEND_SL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
104 {
105 USE_OPLINE
106 zend_free_op free_op1, free_op2;
107
108 SAVE_OPLINE();
109 shift_left_function(&EX_T(opline->result.var).tmp_var,
110 GET_OP1_ZVAL_PTR(BP_VAR_R),
111 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
112 FREE_OP1();
113 FREE_OP2();
114 CHECK_EXCEPTION();
115 ZEND_VM_NEXT_OPCODE();
116 }
117
118 ZEND_VM_HANDLER(7, ZEND_SR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
119 {
120 USE_OPLINE
121 zend_free_op free_op1, free_op2;
122
123 SAVE_OPLINE();
124 shift_right_function(&EX_T(opline->result.var).tmp_var,
125 GET_OP1_ZVAL_PTR(BP_VAR_R),
126 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
127 FREE_OP1();
128 FREE_OP2();
129 CHECK_EXCEPTION();
130 ZEND_VM_NEXT_OPCODE();
131 }
132
133 ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
134 {
135 USE_OPLINE
136 zend_free_op free_op1, free_op2;
137
138 SAVE_OPLINE();
139 concat_function(&EX_T(opline->result.var).tmp_var,
140 GET_OP1_ZVAL_PTR(BP_VAR_R),
141 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
142 FREE_OP1();
143 FREE_OP2();
144 CHECK_EXCEPTION();
145 ZEND_VM_NEXT_OPCODE();
146 }
147
148 ZEND_VM_HANDLER(15, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
149 {
150 USE_OPLINE
151 zend_free_op free_op1, free_op2;
152
153 SAVE_OPLINE();
154 is_identical_function(&EX_T(opline->result.var).tmp_var,
155 GET_OP1_ZVAL_PTR(BP_VAR_R),
156 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
157 FREE_OP1();
158 FREE_OP2();
159 CHECK_EXCEPTION();
160 ZEND_VM_NEXT_OPCODE();
161 }
162
163 ZEND_VM_HANDLER(16, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
164 {
165 USE_OPLINE
166 zend_free_op free_op1, free_op2;
167 zval *result = &EX_T(opline->result.var).tmp_var;
168
169 SAVE_OPLINE();
170 is_identical_function(result,
171 GET_OP1_ZVAL_PTR(BP_VAR_R),
172 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
173 Z_LVAL_P(result) = !Z_LVAL_P(result);
174 FREE_OP1();
175 FREE_OP2();
176 CHECK_EXCEPTION();
177 ZEND_VM_NEXT_OPCODE();
178 }
179
180 ZEND_VM_HANDLER(17, ZEND_IS_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
181 {
182 USE_OPLINE
183 zend_free_op free_op1, free_op2;
184 zval *result = &EX_T(opline->result.var).tmp_var;
185
186 SAVE_OPLINE();
187 ZVAL_BOOL(result, fast_equal_function(result,
188 GET_OP1_ZVAL_PTR(BP_VAR_R),
189 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
190 FREE_OP1();
191 FREE_OP2();
192 CHECK_EXCEPTION();
193 ZEND_VM_NEXT_OPCODE();
194 }
195
196 ZEND_VM_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
197 {
198 USE_OPLINE
199 zend_free_op free_op1, free_op2;
200 zval *result = &EX_T(opline->result.var).tmp_var;
201
202 SAVE_OPLINE();
203 ZVAL_BOOL(result, fast_not_equal_function(result,
204 GET_OP1_ZVAL_PTR(BP_VAR_R),
205 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
206 FREE_OP1();
207 FREE_OP2();
208 CHECK_EXCEPTION();
209 ZEND_VM_NEXT_OPCODE();
210 }
211
212 ZEND_VM_HANDLER(19, ZEND_IS_SMALLER, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
213 {
214 USE_OPLINE
215 zend_free_op free_op1, free_op2;
216 zval *result = &EX_T(opline->result.var).tmp_var;
217
218 SAVE_OPLINE();
219 ZVAL_BOOL(result, fast_is_smaller_function(result,
220 GET_OP1_ZVAL_PTR(BP_VAR_R),
221 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
222 FREE_OP1();
223 FREE_OP2();
224 CHECK_EXCEPTION();
225 ZEND_VM_NEXT_OPCODE();
226 }
227
228 ZEND_VM_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
229 {
230 USE_OPLINE
231 zend_free_op free_op1, free_op2;
232 zval *result = &EX_T(opline->result.var).tmp_var;
233
234 SAVE_OPLINE();
235 ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
236 GET_OP1_ZVAL_PTR(BP_VAR_R),
237 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
238 FREE_OP1();
239 FREE_OP2();
240 CHECK_EXCEPTION();
241 ZEND_VM_NEXT_OPCODE();
242 }
243
244 ZEND_VM_HANDLER(9, ZEND_BW_OR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
245 {
246 USE_OPLINE
247 zend_free_op free_op1, free_op2;
248
249 SAVE_OPLINE();
250 bitwise_or_function(&EX_T(opline->result.var).tmp_var,
251 GET_OP1_ZVAL_PTR(BP_VAR_R),
252 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
253 FREE_OP1();
254 FREE_OP2();
255 CHECK_EXCEPTION();
256 ZEND_VM_NEXT_OPCODE();
257 }
258
259 ZEND_VM_HANDLER(10, ZEND_BW_AND, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
260 {
261 USE_OPLINE
262 zend_free_op free_op1, free_op2;
263
264 SAVE_OPLINE();
265 bitwise_and_function(&EX_T(opline->result.var).tmp_var,
266 GET_OP1_ZVAL_PTR(BP_VAR_R),
267 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
268 FREE_OP1();
269 FREE_OP2();
270 CHECK_EXCEPTION();
271 ZEND_VM_NEXT_OPCODE();
272 }
273
274 ZEND_VM_HANDLER(11, ZEND_BW_XOR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
275 {
276 USE_OPLINE
277 zend_free_op free_op1, free_op2;
278
279 SAVE_OPLINE();
280 bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
281 GET_OP1_ZVAL_PTR(BP_VAR_R),
282 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
283 FREE_OP1();
284 FREE_OP2();
285 CHECK_EXCEPTION();
286 ZEND_VM_NEXT_OPCODE();
287 }
288
289 ZEND_VM_HANDLER(14, ZEND_BOOL_XOR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
290 {
291 USE_OPLINE
292 zend_free_op free_op1, free_op2;
293
294 SAVE_OPLINE();
295 boolean_xor_function(&EX_T(opline->result.var).tmp_var,
296 GET_OP1_ZVAL_PTR(BP_VAR_R),
297 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
298 FREE_OP1();
299 FREE_OP2();
300 CHECK_EXCEPTION();
301 ZEND_VM_NEXT_OPCODE();
302 }
303
304 ZEND_VM_HANDLER(12, ZEND_BW_NOT, CONST|TMP|VAR|CV, ANY)
305 {
306 USE_OPLINE
307 zend_free_op free_op1;
308
309 SAVE_OPLINE();
310 bitwise_not_function(&EX_T(opline->result.var).tmp_var,
311 GET_OP1_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
312 FREE_OP1();
313 CHECK_EXCEPTION();
314 ZEND_VM_NEXT_OPCODE();
315 }
316
317 ZEND_VM_HANDLER(13, ZEND_BOOL_NOT, CONST|TMP|VAR|CV, ANY)
318 {
319 USE_OPLINE
320 zend_free_op free_op1;
321
322 SAVE_OPLINE();
323 boolean_not_function(&EX_T(opline->result.var).tmp_var,
324 GET_OP1_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
325 FREE_OP1();
326 CHECK_EXCEPTION();
327 ZEND_VM_NEXT_OPCODE();
328 }
329
330 ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC))
331 {
332 USE_OPLINE
333 zend_free_op free_op1, free_op2, free_op_data1;
334 zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
335 zval *object;
336 zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
337 zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
338 int have_get_ptr = 0;
339
340 if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
341 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
342 }
343
344 make_real_object(object_ptr TSRMLS_CC);
345 object = *object_ptr;
346
347 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
348 zend_error(E_WARNING, "Attempt to assign property of non-object");
349 FREE_OP2();
350 FREE_OP(free_op_data1);
351
352 if (RETURN_VALUE_USED(opline)) {
353 PZVAL_LOCK(&EG(uninitialized_zval));
354 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
355 }
356 } else {
357
358 if (IS_OP2_TMP_FREE()) {
359 MAKE_REAL_ZVAL_PTR(property);
360 }
361
362
363 if (opline->extended_value == ZEND_ASSIGN_OBJ
364 && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
365 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
366 if (zptr != NULL) {
367 SEPARATE_ZVAL_IF_NOT_REF(zptr);
368
369 have_get_ptr = 1;
370 binary_op(*zptr, *zptr, value TSRMLS_CC);
371 if (RETURN_VALUE_USED(opline)) {
372 PZVAL_LOCK(*zptr);
373 EX_T(opline->result.var).var.ptr = *zptr;
374 }
375 }
376 }
377
378 if (!have_get_ptr) {
379 zval *z = NULL;
380
381 Z_ADDREF_P(object);
382 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
383 if (Z_OBJ_HT_P(object)->read_property) {
384 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
385 }
386 } else {
387 if (Z_OBJ_HT_P(object)->read_dimension) {
388 z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
389 }
390 }
391 if (z) {
392 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
393 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
394
395 if (Z_REFCOUNT_P(z) == 0) {
396 GC_REMOVE_ZVAL_FROM_BUFFER(z);
397 zval_dtor(z);
398 FREE_ZVAL(z);
399 }
400 z = value;
401 }
402 Z_ADDREF_P(z);
403 SEPARATE_ZVAL_IF_NOT_REF(&z);
404 binary_op(z, z, value TSRMLS_CC);
405 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
406 Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
407 } else {
408 Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
409 }
410 if (RETURN_VALUE_USED(opline)) {
411 PZVAL_LOCK(z);
412 EX_T(opline->result.var).var.ptr = z;
413 }
414 zval_ptr_dtor(&z);
415 } else {
416 zend_error(E_WARNING, "Attempt to assign property of non-object");
417 if (RETURN_VALUE_USED(opline)) {
418 PZVAL_LOCK(&EG(uninitialized_zval));
419 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
420 }
421 }
422 zval_ptr_dtor(&object);
423 }
424
425 if (IS_OP2_TMP_FREE()) {
426 zval_ptr_dtor(&property);
427 } else {
428 FREE_OP2();
429 }
430 FREE_OP(free_op_data1);
431 }
432
433 FREE_OP1_VAR_PTR();
434
435 CHECK_EXCEPTION();
436 ZEND_VM_INC_OPCODE();
437 ZEND_VM_NEXT_OPCODE();
438 }
439
440 ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC))
441 {
442 USE_OPLINE
443 zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
444 zval **var_ptr;
445 zval *value;
446
447 SAVE_OPLINE();
448 switch (opline->extended_value) {
449 case ZEND_ASSIGN_OBJ:
450 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op);
451 break;
452 case ZEND_ASSIGN_DIM: {
453 zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
454
455 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
456 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
457 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
458 if (OP1_TYPE == IS_VAR && !OP1_FREE) {
459 Z_ADDREF_PP(container);
460 }
461 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op);
462 } else {
463 zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
464
465 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, OP2_TYPE, BP_VAR_RW TSRMLS_CC);
466 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
467 var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
468 }
469 }
470 break;
471 default:
472 value = GET_OP2_ZVAL_PTR(BP_VAR_R);
473 var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
474
475 break;
476 }
477
478 if (UNEXPECTED(var_ptr == NULL)) {
479 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
480 }
481
482 if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
483 if (RETURN_VALUE_USED(opline)) {
484 PZVAL_LOCK(&EG(uninitialized_zval));
485 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
486 }
487 FREE_OP2();
488 FREE_OP1_VAR_PTR();
489 CHECK_EXCEPTION();
490 if (opline->extended_value == ZEND_ASSIGN_DIM) {
491 ZEND_VM_INC_OPCODE();
492 }
493 ZEND_VM_NEXT_OPCODE();
494 }
495
496 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
497
498 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
499 && Z_OBJ_HANDLER_PP(var_ptr, get)
500 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
501
502 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
503 Z_ADDREF_P(objval);
504 binary_op(objval, objval, value TSRMLS_CC);
505 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
506 zval_ptr_dtor(&objval);
507 } else {
508 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
509 }
510
511 if (RETURN_VALUE_USED(opline)) {
512 PZVAL_LOCK(*var_ptr);
513 EX_T(opline->result.var).var.ptr = *var_ptr;
514 }
515 FREE_OP2();
516
517 if (opline->extended_value == ZEND_ASSIGN_DIM) {
518 FREE_OP(free_op_data1);
519 FREE_OP_VAR_PTR(free_op_data2);
520 FREE_OP1_VAR_PTR();
521 CHECK_EXCEPTION();
522 ZEND_VM_INC_OPCODE();
523 } else {
524 FREE_OP1_VAR_PTR();
525 CHECK_EXCEPTION();
526 }
527 ZEND_VM_NEXT_OPCODE();
528 }
529
530 ZEND_VM_HANDLER(23, ZEND_ASSIGN_ADD, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
531 {
532 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, add_function);
533 }
534
535 ZEND_VM_HANDLER(24, ZEND_ASSIGN_SUB, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
536 {
537 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, sub_function);
538 }
539
540 ZEND_VM_HANDLER(25, ZEND_ASSIGN_MUL, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
541 {
542 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mul_function);
543 }
544
545 ZEND_VM_HANDLER(26, ZEND_ASSIGN_DIV, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
546 {
547 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, div_function);
548 }
549
550 ZEND_VM_HANDLER(27, ZEND_ASSIGN_MOD, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
551 {
552 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mod_function);
553 }
554
555 ZEND_VM_HANDLER(28, ZEND_ASSIGN_SL, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
556 {
557 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_left_function);
558 }
559
560 ZEND_VM_HANDLER(29, ZEND_ASSIGN_SR, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
561 {
562 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_right_function);
563 }
564
565 ZEND_VM_HANDLER(30, ZEND_ASSIGN_CONCAT, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
566 {
567 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, concat_function);
568 }
569
570 ZEND_VM_HANDLER(31, ZEND_ASSIGN_BW_OR, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
571 {
572 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_or_function);
573 }
574
575 ZEND_VM_HANDLER(32, ZEND_ASSIGN_BW_AND, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
576 {
577 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_and_function);
578 }
579
580 ZEND_VM_HANDLER(33, ZEND_ASSIGN_BW_XOR, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
581 {
582 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_xor_function);
583 }
584
585 ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV, incdec_t incdec_op)
586 {
587 USE_OPLINE
588 zend_free_op free_op1, free_op2;
589 zval **object_ptr;
590 zval *object;
591 zval *property;
592 zval **retval;
593 int have_get_ptr = 0;
594
595 SAVE_OPLINE();
596 object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
597 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
598 retval = &EX_T(opline->result.var).var.ptr;
599
600 if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
601 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
602 }
603
604 make_real_object(object_ptr TSRMLS_CC);
605 object = *object_ptr;
606
607 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
608 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
609 FREE_OP2();
610 if (RETURN_VALUE_USED(opline)) {
611 PZVAL_LOCK(&EG(uninitialized_zval));
612 *retval = &EG(uninitialized_zval);
613 }
614 FREE_OP1_VAR_PTR();
615 CHECK_EXCEPTION();
616 ZEND_VM_NEXT_OPCODE();
617 }
618
619
620
621 if (IS_OP2_TMP_FREE()) {
622 MAKE_REAL_ZVAL_PTR(property);
623 }
624
625 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
626 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
627 if (zptr != NULL) {
628 SEPARATE_ZVAL_IF_NOT_REF(zptr);
629
630 have_get_ptr = 1;
631 incdec_op(*zptr);
632 if (RETURN_VALUE_USED(opline)) {
633 *retval = *zptr;
634 PZVAL_LOCK(*retval);
635 }
636 }
637 }
638
639 if (!have_get_ptr) {
640 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
641 zval *z;
642
643 Z_ADDREF_P(object);
644 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
645
646 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
647 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
648
649 if (Z_REFCOUNT_P(z) == 0) {
650 GC_REMOVE_ZVAL_FROM_BUFFER(z);
651 zval_dtor(z);
652 FREE_ZVAL(z);
653 }
654 z = value;
655 }
656 Z_ADDREF_P(z);
657 SEPARATE_ZVAL_IF_NOT_REF(&z);
658 incdec_op(z);
659 *retval = z;
660 Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
661 zval_ptr_dtor(&object);
662 SELECTIVE_PZVAL_LOCK(*retval, opline);
663 zval_ptr_dtor(&z);
664 } else {
665 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
666 if (RETURN_VALUE_USED(opline)) {
667 PZVAL_LOCK(&EG(uninitialized_zval));
668 *retval = &EG(uninitialized_zval);
669 }
670 }
671 }
672
673 if (IS_OP2_TMP_FREE()) {
674 zval_ptr_dtor(&property);
675 } else {
676 FREE_OP2();
677 }
678 FREE_OP1_VAR_PTR();
679 CHECK_EXCEPTION();
680 ZEND_VM_NEXT_OPCODE();
681 }
682
683 ZEND_VM_HANDLER(132, ZEND_PRE_INC_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
684 {
685 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_pre_incdec_property_helper, incdec_op, increment_function);
686 }
687
688 ZEND_VM_HANDLER(133, ZEND_PRE_DEC_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
689 {
690 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_pre_incdec_property_helper, incdec_op, decrement_function);
691 }
692
693 ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV, incdec_t incdec_op)
694 {
695 USE_OPLINE
696 zend_free_op free_op1, free_op2;
697 zval **object_ptr;
698 zval *object;
699 zval *property;
700 zval *retval;
701 int have_get_ptr = 0;
702
703 SAVE_OPLINE();
704 object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
705 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
706 retval = &EX_T(opline->result.var).tmp_var;
707
708 if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
709 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
710 }
711
712 make_real_object(object_ptr TSRMLS_CC);
713 object = *object_ptr;
714
715 if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
716 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
717 FREE_OP2();
718 ZVAL_NULL(retval);
719 FREE_OP1_VAR_PTR();
720 CHECK_EXCEPTION();
721 ZEND_VM_NEXT_OPCODE();
722 }
723
724
725
726 if (IS_OP2_TMP_FREE()) {
727 MAKE_REAL_ZVAL_PTR(property);
728 }
729
730 if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
731 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
732 if (zptr != NULL) {
733 have_get_ptr = 1;
734 SEPARATE_ZVAL_IF_NOT_REF(zptr);
735
736 ZVAL_COPY_VALUE(retval, *zptr);
737 zendi_zval_copy_ctor(*retval);
738
739 incdec_op(*zptr);
740
741 }
742 }
743
744 if (!have_get_ptr) {
745 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
746 zval *z, *z_copy;
747
748 Z_ADDREF_P(object);
749 z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
750 if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
751 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
752
753 if (Z_REFCOUNT_P(z) == 0) {
754 GC_REMOVE_ZVAL_FROM_BUFFER(z);
755 zval_dtor(z);
756 FREE_ZVAL(z);
757 }
758 z = value;
759 }
760 ZVAL_COPY_VALUE(retval, z);
761 zendi_zval_copy_ctor(*retval);
762 ALLOC_ZVAL(z_copy);
763 INIT_PZVAL_COPY(z_copy, z);
764 zendi_zval_copy_ctor(*z_copy);
765 incdec_op(z_copy);
766 Z_ADDREF_P(z);
767 Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
768 zval_ptr_dtor(&object);
769 zval_ptr_dtor(&z_copy);
770 zval_ptr_dtor(&z);
771 } else {
772 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
773 ZVAL_NULL(retval);
774 }
775 }
776
777 if (IS_OP2_TMP_FREE()) {
778 zval_ptr_dtor(&property);
779 } else {
780 FREE_OP2();
781 }
782 FREE_OP1_VAR_PTR();
783 CHECK_EXCEPTION();
784 ZEND_VM_NEXT_OPCODE();
785 }
786
787 ZEND_VM_HANDLER(134, ZEND_POST_INC_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
788 {
789 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_post_incdec_property_helper, incdec_op, increment_function);
790 }
791
792 ZEND_VM_HANDLER(135, ZEND_POST_DEC_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
793 {
794 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_post_incdec_property_helper, incdec_op, decrement_function);
795 }
796
797 ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
798 {
799 USE_OPLINE
800 zend_free_op free_op1;
801 zval **var_ptr;
802
803 SAVE_OPLINE();
804 var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
805
806 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
807 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
808 }
809 if (OP1_TYPE == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
810 if (RETURN_VALUE_USED(opline)) {
811 PZVAL_LOCK(&EG(uninitialized_zval));
812 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
813 }
814 FREE_OP1_VAR_PTR();
815 CHECK_EXCEPTION();
816 ZEND_VM_NEXT_OPCODE();
817 }
818
819 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
820
821 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
822 && Z_OBJ_HANDLER_PP(var_ptr, get)
823 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
824
825 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
826 Z_ADDREF_P(val);
827 fast_increment_function(val);
828 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
829 zval_ptr_dtor(&val);
830 } else {
831 fast_increment_function(*var_ptr);
832 }
833
834 if (RETURN_VALUE_USED(opline)) {
835 PZVAL_LOCK(*var_ptr);
836 EX_T(opline->result.var).var.ptr = *var_ptr;
837 }
838
839 FREE_OP1_VAR_PTR();
840 CHECK_EXCEPTION();
841 ZEND_VM_NEXT_OPCODE();
842 }
843
844 ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
845 {
846 USE_OPLINE
847 zend_free_op free_op1;
848 zval **var_ptr;
849
850 SAVE_OPLINE();
851 var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
852
853 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
854 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
855 }
856 if (OP1_TYPE == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
857 if (RETURN_VALUE_USED(opline)) {
858 PZVAL_LOCK(&EG(uninitialized_zval));
859 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
860 }
861 FREE_OP1_VAR_PTR();
862 CHECK_EXCEPTION();
863 ZEND_VM_NEXT_OPCODE();
864 }
865
866 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
867
868 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
869 && Z_OBJ_HANDLER_PP(var_ptr, get)
870 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
871
872 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
873 Z_ADDREF_P(val);
874 fast_decrement_function(val);
875 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
876 zval_ptr_dtor(&val);
877 } else {
878 fast_decrement_function(*var_ptr);
879 }
880
881 if (RETURN_VALUE_USED(opline)) {
882 PZVAL_LOCK(*var_ptr);
883 EX_T(opline->result.var).var.ptr = *var_ptr;
884 }
885
886 FREE_OP1_VAR_PTR();
887 CHECK_EXCEPTION();
888 ZEND_VM_NEXT_OPCODE();
889 }
890
891 ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
892 {
893 USE_OPLINE
894 zend_free_op free_op1;
895 zval **var_ptr, *retval;
896
897 SAVE_OPLINE();
898 var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
899
900 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
901 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
902 }
903 if (OP1_TYPE == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
904 ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
905 FREE_OP1_VAR_PTR();
906 CHECK_EXCEPTION();
907 ZEND_VM_NEXT_OPCODE();
908 }
909
910 retval = &EX_T(opline->result.var).tmp_var;
911 ZVAL_COPY_VALUE(retval, *var_ptr);
912 zendi_zval_copy_ctor(*retval);
913
914 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
915
916 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
917 && Z_OBJ_HANDLER_PP(var_ptr, get)
918 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
919
920 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
921 Z_ADDREF_P(val);
922 fast_increment_function(val);
923 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
924 zval_ptr_dtor(&val);
925 } else {
926 fast_increment_function(*var_ptr);
927 }
928
929 FREE_OP1_VAR_PTR();
930 CHECK_EXCEPTION();
931 ZEND_VM_NEXT_OPCODE();
932 }
933
934 ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
935 {
936 USE_OPLINE
937 zend_free_op free_op1;
938 zval **var_ptr, *retval;
939
940 SAVE_OPLINE();
941 var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
942
943 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
944 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
945 }
946 if (OP1_TYPE == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
947 ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
948 FREE_OP1_VAR_PTR();
949 CHECK_EXCEPTION();
950 ZEND_VM_NEXT_OPCODE();
951 }
952
953 retval = &EX_T(opline->result.var).tmp_var;
954 ZVAL_COPY_VALUE(retval, *var_ptr);
955 zendi_zval_copy_ctor(*retval);
956
957 SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
958
959 if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
960 && Z_OBJ_HANDLER_PP(var_ptr, get)
961 && Z_OBJ_HANDLER_PP(var_ptr, set)) {
962
963 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
964 Z_ADDREF_P(val);
965 fast_decrement_function(val);
966 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
967 zval_ptr_dtor(&val);
968 } else {
969 fast_decrement_function(*var_ptr);
970 }
971
972 FREE_OP1_VAR_PTR();
973 CHECK_EXCEPTION();
974 ZEND_VM_NEXT_OPCODE();
975 }
976
977 ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMP|VAR|CV, ANY)
978 {
979 USE_OPLINE
980 zend_free_op free_op1;
981 zval *z;
982
983 SAVE_OPLINE();
984 z = GET_OP1_ZVAL_PTR(BP_VAR_R);
985
986 if (OP1_TYPE == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
987 INIT_PZVAL(z);
988 }
989 zend_print_variable(z);
990
991 FREE_OP1();
992 CHECK_EXCEPTION();
993 ZEND_VM_NEXT_OPCODE();
994 }
995
996 ZEND_VM_HANDLER(41, ZEND_PRINT, CONST|TMP|VAR|CV, ANY)
997 {
998 USE_OPLINE
999
1000 ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
1001 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ECHO);
1002 }
1003
1004 ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, UNUSED|CONST|VAR, int type)
1005 {
1006 USE_OPLINE
1007 zend_free_op free_op1;
1008 zval *varname;
1009 zval **retval;
1010 zval tmp_varname;
1011 HashTable *target_symbol_table;
1012 ulong hash_value;
1013
1014 SAVE_OPLINE();
1015 varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
1016
1017 if (OP1_TYPE != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
1018 ZVAL_COPY_VALUE(&tmp_varname, varname);
1019 zval_copy_ctor(&tmp_varname);
1020 Z_SET_REFCOUNT(tmp_varname, 1);
1021 Z_UNSET_ISREF(tmp_varname);
1022 convert_to_string(&tmp_varname);
1023 varname = &tmp_varname;
1024 }
1025
1026 if (OP2_TYPE != IS_UNUSED) {
1027 zend_class_entry *ce;
1028
1029 if (OP2_TYPE == IS_CONST) {
1030 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1031 ce = CACHED_PTR(opline->op2.literal->cache_slot);
1032 } else {
1033 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);
1034 if (UNEXPECTED(ce == NULL)) {
1035 if (OP1_TYPE != IS_CONST && varname == &tmp_varname) {
1036 zval_dtor(&tmp_varname);
1037 }
1038 FREE_OP1();
1039 CHECK_EXCEPTION();
1040 ZEND_VM_NEXT_OPCODE();
1041 }
1042 CACHE_PTR(opline->op2.literal->cache_slot, ce);
1043 }
1044 } else {
1045 ce = EX_T(opline->op2.var).class_entry;
1046 }
1047 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
1048 FREE_OP1();
1049 } else {
1050 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
1051
1052
1053
1054
1055
1056
1057 if (OP1_TYPE == IS_CONST) {
1058 hash_value = Z_HASH_P(varname);
1059 } else {
1060 hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
1061 }
1062
1063 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
1064 switch (type) {
1065 case BP_VAR_R:
1066 case BP_VAR_UNSET:
1067 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
1068
1069 case BP_VAR_IS:
1070 retval = &EG(uninitialized_zval_ptr);
1071 break;
1072 case BP_VAR_RW:
1073 zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
1074
1075 case BP_VAR_W:
1076 Z_ADDREF_P(&EG(uninitialized_zval));
1077 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);
1078 break;
1079 EMPTY_SWITCH_DEFAULT_CASE()
1080 }
1081 }
1082 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
1083 case ZEND_FETCH_GLOBAL:
1084 if (OP1_TYPE != IS_TMP_VAR) {
1085 FREE_OP1();
1086 }
1087 break;
1088 case ZEND_FETCH_LOCAL:
1089 FREE_OP1();
1090 break;
1091 case ZEND_FETCH_STATIC:
1092 zval_update_constant(retval, 1 TSRMLS_CC);
1093 break;
1094 case ZEND_FETCH_GLOBAL_LOCK:
1095 if (OP1_TYPE == IS_VAR && !free_op1.var) {
1096 PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
1097 }
1098 break;
1099 }
1100 }
1101
1102
1103 if (OP1_TYPE != IS_CONST && varname == &tmp_varname) {
1104 zval_dtor(&tmp_varname);
1105 }
1106 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
1107 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
1108 }
1109 PZVAL_LOCK(*retval);
1110 switch (type) {
1111 case BP_VAR_R:
1112 case BP_VAR_IS:
1113 EX_T(opline->result.var).var.ptr = *retval;
1114 break;
1115 case BP_VAR_UNSET: {
1116 zend_free_op free_res;
1117
1118 PZVAL_UNLOCK(*retval, &free_res);
1119 if (retval != &EG(uninitialized_zval_ptr)) {
1120 SEPARATE_ZVAL_IF_NOT_REF(retval);
1121 }
1122 PZVAL_LOCK(*retval);
1123 FREE_OP_VAR_PTR(free_res);
1124 }
1125
1126 default:
1127 EX_T(opline->result.var).var.ptr_ptr = retval;
1128 break;
1129 }
1130 CHECK_EXCEPTION();
1131 ZEND_VM_NEXT_OPCODE();
1132 }
1133
1134 ZEND_VM_HANDLER(80, ZEND_FETCH_R, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
1135 {
1136 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_R);
1137 }
1138
1139 ZEND_VM_HANDLER(83, ZEND_FETCH_W, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
1140 {
1141 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_W);
1142 }
1143
1144 ZEND_VM_HANDLER(86, ZEND_FETCH_RW, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
1145 {
1146 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_RW);
1147 }
1148
1149 ZEND_VM_HANDLER(92, ZEND_FETCH_FUNC_ARG, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
1150 {
1151 USE_OPLINE
1152
1153 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type,
1154 zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R);
1155 }
1156
1157 ZEND_VM_HANDLER(95, ZEND_FETCH_UNSET, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
1158 {
1159 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_UNSET);
1160 }
1161
1162 ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
1163 {
1164 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_IS);
1165 }
1166
1167 ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
1168 {
1169 USE_OPLINE
1170 zend_free_op free_op1, free_op2;
1171 zval *container;
1172
1173 SAVE_OPLINE();
1174 container = GET_OP1_ZVAL_PTR(BP_VAR_R);
1175 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
1176 FREE_OP2();
1177 if (OP1_TYPE != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
1178 FREE_OP1();
1179 }
1180 CHECK_EXCEPTION();
1181 ZEND_VM_NEXT_OPCODE();
1182 }
1183
1184 ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
1185 {
1186 USE_OPLINE
1187 zend_free_op free_op1, free_op2;
1188 zval **container;
1189
1190 SAVE_OPLINE();
1191 container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
1192
1193 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1194 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
1195 }
1196 zend_fetch_dimension_address(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_W TSRMLS_CC);
1197 FREE_OP2();
1198 if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
1199 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
1200 }
1201 FREE_OP1_VAR_PTR();
1202
1203
1204 if (UNEXPECTED(opline->extended_value != 0)) {
1205 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
1206
1207 if (retval_ptr) {
1208 Z_DELREF_PP(retval_ptr);
1209 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
1210 Z_ADDREF_PP(retval_ptr);
1211 }
1212 }
1213
1214 CHECK_EXCEPTION();
1215 ZEND_VM_NEXT_OPCODE();
1216 }
1217
1218 ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
1219 {
1220 USE_OPLINE
1221 zend_free_op free_op1, free_op2;
1222 zval **container;
1223
1224 SAVE_OPLINE();
1225 container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
1226
1227 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1228 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
1229 }
1230 zend_fetch_dimension_address(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_RW TSRMLS_CC);
1231 FREE_OP2();
1232 if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
1233 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
1234 }
1235 FREE_OP1_VAR_PTR();
1236 CHECK_EXCEPTION();
1237 ZEND_VM_NEXT_OPCODE();
1238 }
1239
1240 ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, VAR|CV, CONST|TMP|VAR|CV)
1241 {
1242 USE_OPLINE
1243 zend_free_op free_op1, free_op2;
1244 zval *container;
1245
1246 SAVE_OPLINE();
1247 container = GET_OP1_ZVAL_PTR(BP_VAR_IS);
1248 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_IS TSRMLS_CC);
1249 FREE_OP2();
1250 FREE_OP1();
1251 CHECK_EXCEPTION();
1252 ZEND_VM_NEXT_OPCODE();
1253 }
1254
1255 ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
1256 {
1257 USE_OPLINE
1258 zend_free_op free_op1, free_op2;
1259
1260 SAVE_OPLINE();
1261
1262 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
1263 zval **container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
1264 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1265 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
1266 }
1267 zend_fetch_dimension_address(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_W TSRMLS_CC);
1268 if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
1269 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
1270 }
1271 FREE_OP2();
1272 FREE_OP1_VAR_PTR();
1273 } else {
1274 zval *container;
1275
1276 if (OP2_TYPE == IS_UNUSED) {
1277 zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
1278 }
1279 container = GET_OP1_ZVAL_PTR(BP_VAR_R);
1280 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
1281 FREE_OP2();
1282 FREE_OP1();
1283 }
1284 CHECK_EXCEPTION();
1285 ZEND_VM_NEXT_OPCODE();
1286 }
1287
1288 ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMP|VAR|CV)
1289 {
1290 USE_OPLINE
1291 zend_free_op free_op1, free_op2;
1292 zval **container;
1293
1294 SAVE_OPLINE();
1295 container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_UNSET);
1296
1297 if (OP1_TYPE == IS_CV) {
1298 if (container != &EG(uninitialized_zval_ptr)) {
1299 SEPARATE_ZVAL_IF_NOT_REF(container);
1300 }
1301 }
1302 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1303 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
1304 }
1305 zend_fetch_dimension_address(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_UNSET TSRMLS_CC);
1306 FREE_OP2();
1307 if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
1308 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
1309 }
1310 FREE_OP1_VAR_PTR();
1311 if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
1312 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
1313 ZEND_VM_NEXT_OPCODE();
1314 } else {
1315 zend_free_op free_res;
1316 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
1317
1318 PZVAL_UNLOCK(*retval_ptr, &free_res);
1319 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
1320 SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
1321 }
1322 PZVAL_LOCK(*retval_ptr);
1323 FREE_OP_VAR_PTR(free_res);
1324 CHECK_EXCEPTION();
1325 ZEND_VM_NEXT_OPCODE();
1326 }
1327 }
1328
1329 ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
1330 {
1331 USE_OPLINE
1332 zend_free_op free_op1;
1333 zval *container;
1334 zend_free_op free_op2;
1335 zval *offset;
1336
1337 SAVE_OPLINE();
1338 container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
1339 offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
1340
1341 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
1342 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
1343 zend_error(E_NOTICE, "Trying to get property of non-object");
1344 PZVAL_LOCK(&EG(uninitialized_zval));
1345 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
1346 FREE_OP2();
1347 } else {
1348 zval *retval;
1349
1350 if (IS_OP2_TMP_FREE()) {
1351 MAKE_REAL_ZVAL_PTR(offset);
1352 }
1353
1354
1355 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
1356
1357 PZVAL_LOCK(retval);
1358 EX_T(opline->result.var).var.ptr = retval;
1359
1360 if (IS_OP2_TMP_FREE()) {
1361 zval_ptr_dtor(&offset);
1362 } else {
1363 FREE_OP2();
1364 }
1365 }
1366
1367 FREE_OP1();
1368 CHECK_EXCEPTION();
1369 ZEND_VM_NEXT_OPCODE();
1370 }
1371
1372 ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
1373 {
1374 ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_property_address_read_helper);
1375 }
1376
1377 ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
1378 {
1379 USE_OPLINE
1380 zend_free_op free_op1, free_op2;
1381 zval *property;
1382 zval **container;
1383
1384 SAVE_OPLINE();
1385 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
1386
1387 if (IS_OP2_TMP_FREE()) {
1388 MAKE_REAL_ZVAL_PTR(property);
1389 }
1390 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
1391 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1392 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
1393 }
1394
1395 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
1396 if (IS_OP2_TMP_FREE()) {
1397 zval_ptr_dtor(&property);
1398 } else {
1399 FREE_OP2();
1400 }
1401 if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
1402 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
1403 }
1404 FREE_OP1_VAR_PTR();
1405
1406
1407 if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
1408 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
1409
1410 Z_DELREF_PP(retval_ptr);
1411 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
1412 Z_ADDREF_PP(retval_ptr);
1413 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
1414 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
1415 }
1416
1417 CHECK_EXCEPTION();
1418 ZEND_VM_NEXT_OPCODE();
1419 }
1420
1421 ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
1422 {
1423 USE_OPLINE
1424 zend_free_op free_op1, free_op2;
1425 zval *property;
1426 zval **container;
1427
1428 SAVE_OPLINE();
1429 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
1430 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
1431
1432 if (IS_OP2_TMP_FREE()) {
1433 MAKE_REAL_ZVAL_PTR(property);
1434 }
1435 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1436 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
1437 }
1438 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
1439 if (IS_OP2_TMP_FREE()) {
1440 zval_ptr_dtor(&property);
1441 } else {
1442 FREE_OP2();
1443 }
1444 if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
1445 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
1446 }
1447 FREE_OP1_VAR_PTR();
1448 CHECK_EXCEPTION();
1449 ZEND_VM_NEXT_OPCODE();
1450 }
1451
1452 ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
1453 {
1454 USE_OPLINE
1455 zend_free_op free_op1;
1456 zval *container;
1457 zend_free_op free_op2;
1458 zval *offset;
1459
1460 SAVE_OPLINE();
1461 container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
1462 offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
1463
1464 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
1465 UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
1466 PZVAL_LOCK(&EG(uninitialized_zval));
1467 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
1468 FREE_OP2();
1469 } else {
1470 zval *retval;
1471
1472 if (IS_OP2_TMP_FREE()) {
1473 MAKE_REAL_ZVAL_PTR(offset);
1474 }
1475
1476
1477 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
1478
1479 PZVAL_LOCK(retval);
1480 EX_T(opline->result.var).var.ptr = retval;
1481
1482 if (IS_OP2_TMP_FREE()) {
1483 zval_ptr_dtor(&offset);
1484 } else {
1485 FREE_OP2();
1486 }
1487 }
1488
1489 FREE_OP1();
1490 CHECK_EXCEPTION();
1491 ZEND_VM_NEXT_OPCODE();
1492 }
1493
1494 ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
1495 {
1496 USE_OPLINE
1497
1498 if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
1499
1500 zend_free_op free_op1, free_op2;
1501 zval *property;
1502 zval **container;
1503
1504 SAVE_OPLINE();
1505 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
1506 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
1507
1508 if (IS_OP2_TMP_FREE()) {
1509 MAKE_REAL_ZVAL_PTR(property);
1510 }
1511 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1512 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
1513 }
1514 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
1515 if (IS_OP2_TMP_FREE()) {
1516 zval_ptr_dtor(&property);
1517 } else {
1518 FREE_OP2();
1519 }
1520 if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
1521 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
1522 }
1523 FREE_OP1_VAR_PTR();
1524 CHECK_EXCEPTION();
1525 ZEND_VM_NEXT_OPCODE();
1526 } else {
1527 ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_property_address_read_helper);
1528 }
1529 }
1530
1531 ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
1532 {
1533 USE_OPLINE
1534 zend_free_op free_op1, free_op2, free_res;
1535 zval **container;
1536 zval *property;
1537
1538 SAVE_OPLINE();
1539 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
1540 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
1541
1542 if (OP1_TYPE == IS_CV) {
1543 if (container != &EG(uninitialized_zval_ptr)) {
1544 SEPARATE_ZVAL_IF_NOT_REF(container);
1545 }
1546 }
1547 if (IS_OP2_TMP_FREE()) {
1548 MAKE_REAL_ZVAL_PTR(property);
1549 }
1550 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1551 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
1552 }
1553 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
1554 if (IS_OP2_TMP_FREE()) {
1555 zval_ptr_dtor(&property);
1556 } else {
1557 FREE_OP2();
1558 }
1559 if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
1560 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
1561 }
1562 FREE_OP1_VAR_PTR();
1563
1564 PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
1565 if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
1566 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
1567 }
1568 PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
1569 FREE_OP_VAR_PTR(free_res);
1570 CHECK_EXCEPTION();
1571 ZEND_VM_NEXT_OPCODE();
1572 }
1573
1574 ZEND_VM_HANDLER(98, ZEND_FETCH_DIM_TMP_VAR, CONST|TMP, CONST)
1575 {
1576 USE_OPLINE
1577 zend_free_op free_op1;
1578 zval *container;
1579
1580 SAVE_OPLINE();
1581 container = GET_OP1_ZVAL_PTR(BP_VAR_R);
1582
1583 if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
1584 PZVAL_LOCK(&EG(uninitialized_zval));
1585 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
1586 } else {
1587 zend_free_op free_op2;
1588 zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
1589
1590 PZVAL_LOCK(value);
1591 EX_T(opline->result.var).var.ptr = value;
1592 FREE_OP2();
1593 }
1594 CHECK_EXCEPTION();
1595 ZEND_VM_NEXT_OPCODE();
1596 }
1597
1598 ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
1599 {
1600 USE_OPLINE
1601 zend_free_op free_op1, free_op2;
1602 zval **object_ptr;
1603 zval *property_name;
1604
1605 SAVE_OPLINE();
1606 object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
1607 property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
1608
1609 if (IS_OP2_TMP_FREE()) {
1610 MAKE_REAL_ZVAL_PTR(property_name);
1611 }
1612 if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
1613 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
1614 }
1615 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, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
1616 if (IS_OP2_TMP_FREE()) {
1617 zval_ptr_dtor(&property_name);
1618 } else {
1619 FREE_OP2();
1620 }
1621 FREE_OP1_VAR_PTR();
1622
1623 CHECK_EXCEPTION();
1624 ZEND_VM_INC_OPCODE();
1625 ZEND_VM_NEXT_OPCODE();
1626 }
1627
1628 ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
1629 {
1630 USE_OPLINE
1631 zend_free_op free_op1;
1632 zval **object_ptr;
1633
1634 SAVE_OPLINE();
1635 object_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
1636
1637 if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
1638 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
1639 }
1640 if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
1641 zend_free_op free_op2;
1642 zval *property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
1643
1644 if (IS_OP2_TMP_FREE()) {
1645 MAKE_REAL_ZVAL_PTR(property_name);
1646 }
1647 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, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
1648 if (IS_OP2_TMP_FREE()) {
1649 zval_ptr_dtor(&property_name);
1650 } else {
1651 FREE_OP2();
1652 }
1653 } else {
1654 zend_free_op free_op2, free_op_data1, free_op_data2;
1655 zval *value;
1656 zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
1657 zval **variable_ptr_ptr;
1658
1659 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, OP2_TYPE, BP_VAR_W TSRMLS_CC);
1660 FREE_OP2();
1661
1662 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
1663 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
1664 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
1665 if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
1666 if (RETURN_VALUE_USED(opline)) {
1667 zval *retval;
1668
1669 ALLOC_ZVAL(retval);
1670 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);
1671 INIT_PZVAL(retval);
1672 EX_T(opline->result.var).var.ptr = retval;
1673 }
1674 } else if (RETURN_VALUE_USED(opline)) {
1675 PZVAL_LOCK(&EG(uninitialized_zval));
1676 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
1677 }
1678 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
1679 if (IS_TMP_FREE(free_op_data1)) {
1680 zval_dtor(value);
1681 }
1682 if (RETURN_VALUE_USED(opline)) {
1683 PZVAL_LOCK(&EG(uninitialized_zval));
1684 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
1685 }
1686 } else {
1687 if ((opline+1)->op1_type == IS_TMP_VAR) {
1688 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
1689 } else if ((opline+1)->op1_type == IS_CONST) {
1690 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
1691 } else {
1692 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
1693 }
1694 if (RETURN_VALUE_USED(opline)) {
1695 PZVAL_LOCK(value);
1696 EX_T(opline->result.var).var.ptr = value;
1697 }
1698 }
1699 FREE_OP_VAR_PTR(free_op_data2);
1700 FREE_OP_IF_VAR(free_op_data1);
1701 }
1702 FREE_OP1_VAR_PTR();
1703
1704 CHECK_EXCEPTION();
1705 ZEND_VM_INC_OPCODE();
1706 ZEND_VM_NEXT_OPCODE();
1707 }
1708
1709 ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
1710 {
1711 USE_OPLINE
1712 zend_free_op free_op1, free_op2;
1713 zval *value;
1714 zval **variable_ptr_ptr;
1715
1716 SAVE_OPLINE();
1717 value = GET_OP2_ZVAL_PTR(BP_VAR_R);
1718 variable_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
1719
1720 if (OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
1721 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, OP2_TYPE TSRMLS_CC)) {
1722 if (RETURN_VALUE_USED(opline)) {
1723 zval *retval;
1724
1725 ALLOC_ZVAL(retval);
1726 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
1727 INIT_PZVAL(retval);
1728 EX_T(opline->result.var).var.ptr = retval;
1729 }
1730 } else if (RETURN_VALUE_USED(opline)) {
1731 PZVAL_LOCK(&EG(uninitialized_zval));
1732 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
1733 }
1734 } else if (OP1_TYPE == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
1735 if (IS_OP2_TMP_FREE()) {
1736 zval_dtor(value);
1737 }
1738 if (RETURN_VALUE_USED(opline)) {
1739 PZVAL_LOCK(&EG(uninitialized_zval));
1740 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
1741 }
1742 } else {
1743 if (OP2_TYPE == IS_TMP_VAR) {
1744 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
1745 } else if (OP2_TYPE == IS_CONST) {
1746 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
1747 } else {
1748 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
1749 }
1750 if (RETURN_VALUE_USED(opline)) {
1751 PZVAL_LOCK(value);
1752 EX_T(opline->result.var).var.ptr = value;
1753 }
1754 }
1755
1756 if (OP1_TYPE == IS_VAR && OP1_FREE) {
1757 zval_ptr_dtor_nogc(&value);
1758 }
1759
1760
1761 FREE_OP2_IF_VAR();
1762
1763 CHECK_EXCEPTION();
1764 ZEND_VM_NEXT_OPCODE();
1765 }
1766
1767 ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV)
1768 {
1769 USE_OPLINE
1770 zend_free_op free_op1, free_op2;
1771 zval **variable_ptr_ptr;
1772 zval **value_ptr_ptr;
1773
1774 SAVE_OPLINE();
1775 value_ptr_ptr = GET_OP2_ZVAL_PTR_PTR(BP_VAR_W);
1776
1777 if (OP1_TYPE == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
1778 zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
1779 }
1780
1781 if (OP2_TYPE == IS_VAR &&
1782 value_ptr_ptr &&
1783 !Z_ISREF_PP(value_ptr_ptr) &&
1784 opline->extended_value == ZEND_RETURNS_FUNCTION &&
1785 !EX_T(opline->op2.var).var.fcall_returned_reference) {
1786 if (free_op2.var == NULL) {
1787 PZVAL_LOCK(*value_ptr_ptr);
1788 }
1789 zend_error(E_STRICT, "Only variables should be assigned by reference");
1790 if (UNEXPECTED(EG(exception) != NULL)) {
1791 FREE_OP2_VAR_PTR();
1792 HANDLE_EXCEPTION();
1793 }
1794 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ASSIGN);
1795 } else if (OP2_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
1796 PZVAL_LOCK(*value_ptr_ptr);
1797 }
1798
1799 variable_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
1800 if ((OP2_TYPE == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
1801 (OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
1802 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
1803 }
1804 zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
1805
1806 if (OP2_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
1807 Z_DELREF_PP(variable_ptr_ptr);
1808 }
1809
1810 if (RETURN_VALUE_USED(opline)) {
1811 PZVAL_LOCK(*variable_ptr_ptr);
1812 EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
1813 }
1814
1815 FREE_OP1_VAR_PTR();
1816 FREE_OP2_VAR_PTR();
1817
1818 CHECK_EXCEPTION();
1819 ZEND_VM_NEXT_OPCODE();
1820 }
1821
1822 ZEND_VM_HELPER(zend_leave_helper, ANY, ANY)
1823 {
1824 zend_bool nested = EX(nested);
1825 zend_op_array *op_array = EX(op_array);
1826
1827 EG(current_execute_data) = EX(prev_execute_data);
1828 EG(opline_ptr) = NULL;
1829 if (!EG(active_symbol_table)) {
1830 i_free_compiled_variables(execute_data TSRMLS_CC);
1831 }
1832
1833 zend_vm_stack_free((char*)execute_data - (ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T) TSRMLS_CC);
1834
1835 if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) {
1836 zval_ptr_dtor((zval**)&op_array->prototype);
1837 }
1838
1839 if (nested) {
1840 execute_data = EG(current_execute_data);
1841 }
1842 if (nested) {
1843 USE_OPLINE
1844
1845 LOAD_REGS();
1846 LOAD_OPLINE();
1847 if (UNEXPECTED(opline->opcode == ZEND_INCLUDE_OR_EVAL)) {
1848
1849 EX(function_state).function = (zend_function *) EX(op_array);
1850 EX(function_state).arguments = NULL;
1851
1852 EG(opline_ptr) = &EX(opline);
1853 EG(active_op_array) = EX(op_array);
1854 EG(return_value_ptr_ptr) = EX(original_return_value);
1855 destroy_op_array(op_array TSRMLS_CC);
1856 efree(op_array);
1857 if (UNEXPECTED(EG(exception) != NULL)) {
1858 zend_throw_exception_internal(NULL TSRMLS_CC);
1859 HANDLE_EXCEPTION_LEAVE();
1860 }
1861
1862 ZEND_VM_INC_OPCODE();
1863 ZEND_VM_LEAVE();
1864 } else {
1865 EG(opline_ptr) = &EX(opline);
1866 EG(active_op_array) = EX(op_array);
1867 EG(return_value_ptr_ptr) = EX(original_return_value);
1868 if (EG(active_symbol_table)) {
1869 zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
1870 }
1871 EG(active_symbol_table) = EX(symbol_table);
1872
1873 EX(function_state).function = (zend_function *) EX(op_array);
1874 EX(function_state).arguments = NULL;
1875
1876 if (EG(This)) {
1877 if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
1878 if (EX(call)->is_ctor_result_used) {
1879 Z_DELREF_P(EG(This));
1880 }
1881 if (Z_REFCOUNT_P(EG(This)) == 1) {
1882 zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
1883 }
1884 }
1885 zval_ptr_dtor(&EG(This));
1886 }
1887 EG(This) = EX(current_this);
1888 EG(scope) = EX(current_scope);
1889 EG(called_scope) = EX(current_called_scope);
1890
1891 EX(call)--;
1892
1893 zend_vm_stack_clear_multiple(0 TSRMLS_CC);
1894
1895 if (UNEXPECTED(EG(exception) != NULL)) {
1896 zend_throw_exception_internal(NULL TSRMLS_CC);
1897 if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) {
1898 zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
1899 }
1900 HANDLE_EXCEPTION_LEAVE();
1901 }
1902
1903 ZEND_VM_INC_OPCODE();
1904 ZEND_VM_LEAVE();
1905 }
1906 }
1907 ZEND_VM_RETURN();
1908 }
1909
1910 ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
1911 {
1912 USE_OPLINE
1913 zend_bool should_change_scope = 0;
1914 zend_function *fbc = EX(function_state).function;
1915 zend_uint num_args;
1916
1917 SAVE_OPLINE();
1918 EX(object) = EX(call)->object;
1919 if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) {
1920 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) {
1921 zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name, fbc->common.function_name);
1922 }
1923 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1924 zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
1925 fbc->common.scope ? fbc->common.scope->name : "",
1926 fbc->common.scope ? "::" : "",
1927 fbc->common.function_name);
1928 if (UNEXPECTED(EG(exception) != NULL)) {
1929 HANDLE_EXCEPTION();
1930 }
1931 }
1932 }
1933 if (fbc->common.scope &&
1934 !(fbc->common.fn_flags & ZEND_ACC_STATIC) &&
1935 !EX(object)) {
1936
1937 if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
1938
1939 zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name, fbc->common.function_name);
1940 if (UNEXPECTED(EG(exception) != NULL)) {
1941 HANDLE_EXCEPTION();
1942 }
1943 } else {
1944
1945
1946 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name, fbc->common.function_name);
1947 }
1948 }
1949
1950 if (fbc->type == ZEND_USER_FUNCTION || fbc->common.scope) {
1951 should_change_scope = 1;
1952 EX(current_this) = EG(This);
1953 EX(current_scope) = EG(scope);
1954 EX(current_called_scope) = EG(called_scope);
1955 EG(This) = EX(object);
1956 EG(scope) = (fbc->type == ZEND_USER_FUNCTION || !EX(object)) ? fbc->common.scope : NULL;
1957 EG(called_scope) = EX(call)->called_scope;
1958 }
1959
1960 num_args = opline->extended_value + EX(call)->num_additional_args;
1961 if (EX(call)->num_additional_args) {
1962 EX(function_state).arguments = zend_vm_stack_push_args(num_args TSRMLS_CC);
1963 } else {
1964 EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
1965 zend_vm_stack_push((void*)(zend_uintptr_t) num_args TSRMLS_CC);
1966 }
1967 LOAD_OPLINE();
1968
1969 if (fbc->type == ZEND_INTERNAL_FUNCTION) {
1970 if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
1971 zend_uint i;
1972 void **p = EX(function_state).arguments - num_args;
1973
1974 for (i = 0; i < num_args; ++i, ++p) {
1975 zend_verify_arg_type(fbc, i + 1, (zval *) *p, 0, NULL TSRMLS_CC);
1976 }
1977 }
1978
1979 if (EXPECTED(EG(exception) == NULL)) {
1980 temp_variable *ret = &EX_T(opline->result.var);
1981
1982 MAKE_STD_ZVAL(ret->var.ptr);
1983 ZVAL_NULL(ret->var.ptr);
1984 ret->var.ptr_ptr = &ret->var.ptr;
1985 ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
1986
1987 if (!zend_execute_internal) {
1988
1989 fbc->internal_function.handler(num_args, ret->var.ptr, &ret->var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
1990 } else {
1991 zend_execute_internal(execute_data, NULL, RETURN_VALUE_USED(opline) TSRMLS_CC);
1992 }
1993
1994 if (!RETURN_VALUE_USED(opline)) {
1995 zval_ptr_dtor(&ret->var.ptr);
1996 }
1997 } else if (RETURN_VALUE_USED(opline)) {
1998 EX_T(opline->result.var).var.ptr = NULL;
1999 }
2000 } else if (fbc->type == ZEND_USER_FUNCTION) {
2001 temp_variable *ret = &EX_T(opline->result.var);
2002 EX(original_return_value) = EG(return_value_ptr_ptr);
2003 EG(active_symbol_table) = NULL;
2004 EG(active_op_array) = &fbc->op_array;
2005 EG(return_value_ptr_ptr) = NULL;
2006 if (RETURN_VALUE_USED(opline)) {
2007 ret->var.ptr = NULL;
2008 EG(return_value_ptr_ptr) = &ret->var.ptr;
2009 ret->var.ptr_ptr = &ret->var.ptr;
2010 ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
2011 }
2012
2013 if (UNEXPECTED((EG(active_op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
2014 if (RETURN_VALUE_USED(opline)) {
2015 ret->var.ptr = zend_generator_create_zval(EG(active_op_array) TSRMLS_CC);
2016 ret->var.fcall_returned_reference = 0;
2017 }
2018 } else if (EXPECTED(zend_execute_ex == execute_ex)) {
2019 if (EXPECTED(EG(exception) == NULL)) {
2020 ZEND_VM_ENTER();
2021 }
2022 } else {
2023 zend_execute(EG(active_op_array) TSRMLS_CC);
2024 }
2025
2026 EG(opline_ptr) = &EX(opline);
2027 EG(active_op_array) = EX(op_array);
2028 EG(return_value_ptr_ptr) = EX(original_return_value);
2029 if (EG(active_symbol_table)) {
2030 zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
2031 }
2032 EG(active_symbol_table) = EX(symbol_table);
2033 } else {
2034 MAKE_STD_ZVAL(EX_T(opline->result.var).var.ptr);
2035 ZVAL_NULL(EX_T(opline->result.var).var.ptr);
2036
2037
2038 if (EXPECTED(EX(object) != NULL)) {
2039 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);
2040 } else {
2041 zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
2042 }
2043
2044 if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
2045 efree((char*)fbc->common.function_name);
2046 }
2047 efree(fbc);
2048
2049 if (!RETURN_VALUE_USED(opline)) {
2050 zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
2051 } else {
2052 Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr);
2053 Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1);
2054 EX_T(opline->result.var).var.fcall_returned_reference = 0;
2055 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
2056 }
2057 }
2058
2059 EX(function_state).function = (zend_function *) EX(op_array);
2060 EX(function_state).arguments = NULL;
2061
2062 if (should_change_scope) {
2063 if (EG(This)) {
2064 if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
2065 if (EX(call)->is_ctor_result_used) {
2066 Z_DELREF_P(EG(This));
2067 }
2068 if (Z_REFCOUNT_P(EG(This)) == 1) {
2069 zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
2070 }
2071 }
2072 zval_ptr_dtor(&EG(This));
2073 }
2074 EG(This) = EX(current_this);
2075 EG(scope) = EX(current_scope);
2076 EG(called_scope) = EX(current_called_scope);
2077 }
2078
2079 EX(call)--;
2080
2081 zend_vm_stack_clear_multiple(0 TSRMLS_CC);
2082
2083 if (UNEXPECTED(EG(exception) != NULL)) {
2084 zend_throw_exception_internal(NULL TSRMLS_CC);
2085 if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) {
2086 zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
2087 }
2088 HANDLE_EXCEPTION();
2089 }
2090
2091 ZEND_VM_NEXT_OPCODE();
2092 }
2093
2094 ZEND_VM_HANDLER(42, ZEND_JMP, ANY, ANY)
2095 {
2096 USE_OPLINE
2097
2098 #if DEBUG_ZEND>=2
2099 printf("Jumping to %d\n", opline->op1.opline_num);
2100 #endif
2101 ZEND_VM_SET_OPCODE(opline->op1.jmp_addr);
2102 ZEND_VM_CONTINUE();
2103 }
2104
2105 ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMP|VAR|CV, ANY)
2106 {
2107 USE_OPLINE
2108 zend_free_op free_op1;
2109 zval *val;
2110 int ret;
2111
2112 SAVE_OPLINE();
2113 val = GET_OP1_ZVAL_PTR(BP_VAR_R);
2114
2115 if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2116 ret = Z_LVAL_P(val);
2117 } else {
2118 ret = i_zend_is_true(val);
2119 FREE_OP1();
2120 if (UNEXPECTED(EG(exception) != NULL)) {
2121 HANDLE_EXCEPTION();
2122 }
2123 }
2124 if (!ret) {
2125 #if DEBUG_ZEND>=2
2126 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2127 #endif
2128 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2129 ZEND_VM_CONTINUE();
2130 }
2131
2132 ZEND_VM_NEXT_OPCODE();
2133 }
2134
2135 ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMP|VAR|CV, ANY)
2136 {
2137 USE_OPLINE
2138 zend_free_op free_op1;
2139 zval *val;
2140 int ret;
2141
2142 SAVE_OPLINE();
2143 val = GET_OP1_ZVAL_PTR(BP_VAR_R);
2144
2145 if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2146 ret = Z_LVAL_P(val);
2147 } else {
2148 ret = i_zend_is_true(val);
2149 FREE_OP1();
2150 if (UNEXPECTED(EG(exception) != NULL)) {
2151 HANDLE_EXCEPTION();
2152 }
2153 }
2154 if (ret) {
2155 #if DEBUG_ZEND>=2
2156 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2157 #endif
2158 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2159 ZEND_VM_CONTINUE();
2160 }
2161
2162 ZEND_VM_NEXT_OPCODE();
2163 }
2164
2165 ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMP|VAR|CV, ANY)
2166 {
2167 USE_OPLINE
2168 zend_free_op free_op1;
2169 zval *val;
2170 int retval;
2171
2172 SAVE_OPLINE();
2173 val = GET_OP1_ZVAL_PTR(BP_VAR_R);
2174
2175 if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2176 retval = Z_LVAL_P(val);
2177 } else {
2178 retval = i_zend_is_true(val);
2179 FREE_OP1();
2180 if (UNEXPECTED(EG(exception) != NULL)) {
2181 HANDLE_EXCEPTION();
2182 }
2183 }
2184 if (EXPECTED(retval != 0)) {
2185 #if DEBUG_ZEND>=2
2186 printf("Conditional jmp on true to %d\n", opline->extended_value);
2187 #endif
2188 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
2189 ZEND_VM_CONTINUE();
2190 } else {
2191 #if DEBUG_ZEND>=2
2192 printf("Conditional jmp on false to %d\n", opline->op2.opline_num);
2193 #endif
2194 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
2195 ZEND_VM_CONTINUE();
2196 }
2197 }
2198
2199 ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMP|VAR|CV, ANY)
2200 {
2201 USE_OPLINE
2202 zend_free_op free_op1;
2203 zval *val;
2204 int retval;
2205
2206 SAVE_OPLINE();
2207 val = GET_OP1_ZVAL_PTR(BP_VAR_R);
2208
2209 if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2210 retval = Z_LVAL_P(val);
2211 } else {
2212 retval = i_zend_is_true(val);
2213 FREE_OP1();
2214 if (UNEXPECTED(EG(exception) != NULL)) {
2215 HANDLE_EXCEPTION();
2216 }
2217 }
2218 Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
2219 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
2220 if (!retval) {
2221 #if DEBUG_ZEND>=2
2222 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2223 #endif
2224 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2225 ZEND_VM_CONTINUE();
2226 }
2227 ZEND_VM_NEXT_OPCODE();
2228 }
2229
2230 ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMP|VAR|CV, ANY)
2231 {
2232 USE_OPLINE
2233 zend_free_op free_op1;
2234 zval *val;
2235 int retval;
2236
2237 SAVE_OPLINE();
2238 val = GET_OP1_ZVAL_PTR(BP_VAR_R);
2239
2240 if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2241 retval = Z_LVAL_P(val);
2242 } else {
2243 retval = i_zend_is_true(val);
2244 FREE_OP1();
2245 if (UNEXPECTED(EG(exception) != NULL)) {
2246 HANDLE_EXCEPTION();
2247 }
2248 }
2249 Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
2250 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
2251 if (retval) {
2252 #if DEBUG_ZEND>=2
2253 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2254 #endif
2255 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2256 ZEND_VM_CONTINUE();
2257 }
2258 ZEND_VM_NEXT_OPCODE();
2259 }
2260
2261 ZEND_VM_HANDLER(70, ZEND_FREE, TMP|VAR, ANY)
2262 {
2263 USE_OPLINE
2264
2265 SAVE_OPLINE();
2266 if (OP1_TYPE == IS_TMP_VAR) {
2267 zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
2268 } else {
2269 zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
2270 }
2271 CHECK_EXCEPTION();
2272 ZEND_VM_NEXT_OPCODE();
2273 }
2274
2275 ZEND_VM_HANDLER(53, ZEND_INIT_STRING, ANY, ANY)
2276 {
2277 USE_OPLINE
2278 zval *tmp = &EX_T(opline->result.var).tmp_var;
2279
2280 SAVE_OPLINE();
2281 tmp->value.str.val = emalloc(1);
2282 tmp->value.str.val[0] = 0;
2283 tmp->value.str.len = 0;
2284 Z_SET_REFCOUNT_P(tmp, 1);
2285 tmp->type = IS_STRING;
2286 Z_UNSET_ISREF_P(tmp);
2287
2288 ZEND_VM_NEXT_OPCODE();
2289 }
2290
2291 ZEND_VM_HANDLER(54, ZEND_ADD_CHAR, TMP|UNUSED, CONST)
2292 {
2293 USE_OPLINE
2294 zval *str = &EX_T(opline->result.var).tmp_var;
2295
2296 SAVE_OPLINE();
2297
2298 if (OP1_TYPE == IS_UNUSED) {
2299
2300 Z_STRVAL_P(str) = NULL;
2301 Z_STRLEN_P(str) = 0;
2302 Z_TYPE_P(str) = IS_STRING;
2303
2304 INIT_PZVAL(str);
2305 }
2306
2307 add_char_to_string(str, str, opline->op2.zv);
2308
2309
2310
2311 ZEND_VM_NEXT_OPCODE();
2312 }
2313
2314 ZEND_VM_HANDLER(55, ZEND_ADD_STRING, TMP|UNUSED, CONST)
2315 {
2316 USE_OPLINE
2317 zval *str = &EX_T(opline->result.var).tmp_var;
2318
2319 SAVE_OPLINE();
2320
2321 if (OP1_TYPE == IS_UNUSED) {
2322
2323 Z_STRVAL_P(str) = NULL;
2324 Z_STRLEN_P(str) = 0;
2325 Z_TYPE_P(str) = IS_STRING;
2326
2327 INIT_PZVAL(str);
2328 }
2329
2330 add_string_to_string(str, str, opline->op2.zv);
2331
2332
2333
2334 ZEND_VM_NEXT_OPCODE();
2335 }
2336
2337 ZEND_VM_HANDLER(56, ZEND_ADD_VAR, TMP|UNUSED, TMP|VAR|CV)
2338 {
2339 USE_OPLINE
2340 zend_free_op free_op2;
2341 zval *str = &EX_T(opline->result.var).tmp_var;
2342 zval *var;
2343 zval var_copy;
2344 int use_copy = 0;
2345
2346 SAVE_OPLINE();
2347 var = GET_OP2_ZVAL_PTR(BP_VAR_R);
2348
2349 if (OP1_TYPE == IS_UNUSED) {
2350
2351 Z_STRVAL_P(str) = NULL;
2352 Z_STRLEN_P(str) = 0;
2353 Z_TYPE_P(str) = IS_STRING;
2354
2355 INIT_PZVAL(str);
2356 }
2357
2358 if (Z_TYPE_P(var) != IS_STRING) {
2359 zend_make_printable_zval(var, &var_copy, &use_copy);
2360
2361 if (use_copy) {
2362 var = &var_copy;
2363 }
2364 }
2365 add_string_to_string(str, str, var);
2366
2367 if (use_copy) {
2368 zval_dtor(var);
2369 }
2370
2371
2372
2373
2374
2375
2376 FREE_OP2();
2377
2378 CHECK_EXCEPTION();
2379 ZEND_VM_NEXT_OPCODE();
2380 }
2381
2382 ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMP|VAR|UNUSED|CV)
2383 {
2384 USE_OPLINE
2385
2386 SAVE_OPLINE();
2387 if (EG(exception)) {
2388 zend_exception_save(TSRMLS_C);
2389 }
2390 if (OP2_TYPE == IS_UNUSED) {
2391 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
2392 CHECK_EXCEPTION();
2393 ZEND_VM_NEXT_OPCODE();
2394 } else {
2395 zend_free_op free_op2;
2396 zval *class_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
2397
2398 if (OP2_TYPE == IS_CONST) {
2399 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
2400 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
2401 } else {
2402 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);
2403 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
2404 }
2405 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
2406 EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
2407 } else if (Z_TYPE_P(class_name) == IS_STRING) {
2408 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);
2409 } else {
2410 if (UNEXPECTED(EG(exception) != NULL)) {
2411 HANDLE_EXCEPTION();
2412 }
2413 zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
2414 }
2415
2416 FREE_OP2();
2417 CHECK_EXCEPTION();
2418 ZEND_VM_NEXT_OPCODE();
2419 }
2420 }
2421
2422 ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
2423 {
2424 USE_OPLINE
2425 zval *function_name;
2426 char *function_name_strval;
2427 int function_name_strlen;
2428 zend_free_op free_op1, free_op2;
2429 call_slot *call = EX(call_slots) + opline->result.num;
2430
2431 SAVE_OPLINE();
2432
2433 function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
2434
2435 if (OP2_TYPE != IS_CONST &&
2436 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
2437 if (UNEXPECTED(EG(exception) != NULL)) {
2438 HANDLE_EXCEPTION();
2439 }
2440 zend_error_noreturn(E_ERROR, "Method name must be a string");
2441 }
2442
2443 function_name_strval = Z_STRVAL_P(function_name);
2444 function_name_strlen = Z_STRLEN_P(function_name);
2445
2446 call->object = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
2447
2448 if (EXPECTED(call->object != NULL) &&
2449 EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
2450 call->called_scope = Z_OBJCE_P(call->object);
2451
2452 if (OP2_TYPE != IS_CONST ||
2453 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
2454 zval *object = call->object;
2455
2456 if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
2457 zend_error_noreturn(E_ERROR, "Object does not support method calls");
2458 }
2459
2460
2461 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((OP2_TYPE == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
2462 if (UNEXPECTED(call->fbc == NULL)) {
2463 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
2464 }
2465 if (OP2_TYPE == IS_CONST &&
2466 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
2467 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
2468 EXPECTED(call->object == object)) {
2469 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
2470 }
2471 }
2472 } else {
2473 if (UNEXPECTED(EG(exception) != NULL)) {
2474 FREE_OP2();
2475 HANDLE_EXCEPTION();
2476 }
2477 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)));
2478 }
2479
2480 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
2481 call->object = NULL;
2482 } else {
2483 if (!PZVAL_IS_REF(call->object)) {
2484 Z_ADDREF_P(call->object);
2485 } else {
2486 zval *this_ptr;
2487 ALLOC_ZVAL(this_ptr);
2488 INIT_PZVAL_COPY(this_ptr, call->object);
2489 zval_copy_ctor(this_ptr);
2490 call->object = this_ptr;
2491 }
2492 }
2493
2494 call->num_additional_args = 0;
2495 call->is_ctor_call = 0;
2496 EX(call) = call;
2497
2498 FREE_OP2();
2499 FREE_OP1_IF_VAR();
2500
2501 CHECK_EXCEPTION();
2502 ZEND_VM_NEXT_OPCODE();
2503 }
2504
2505 ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUSED|CV)
2506 {
2507 USE_OPLINE
2508 zval *function_name;
2509 zend_class_entry *ce;
2510 call_slot *call = EX(call_slots) + opline->result.num;
2511
2512 SAVE_OPLINE();
2513
2514 if (OP1_TYPE == IS_CONST) {
2515
2516 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
2517 ce = CACHED_PTR(opline->op1.literal->cache_slot);
2518 } else {
2519 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);
2520 if (UNEXPECTED(EG(exception) != NULL)) {
2521 HANDLE_EXCEPTION();
2522 }
2523 if (UNEXPECTED(ce == NULL)) {
2524 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
2525 }
2526 CACHE_PTR(opline->op1.literal->cache_slot, ce);
2527 }
2528 call->called_scope = ce;
2529 } else {
2530 ce = EX_T(opline->op1.var).class_entry;
2531
2532 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
2533 call->called_scope = EG(called_scope);
2534 } else {
2535 call->called_scope = ce;
2536 }
2537 }
2538
2539 if (OP1_TYPE == IS_CONST &&
2540 OP2_TYPE == IS_CONST &&
2541 CACHED_PTR(opline->op2.literal->cache_slot)) {
2542 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
2543 } else if (OP1_TYPE != IS_CONST &&
2544 OP2_TYPE == IS_CONST &&
2545 (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
2546
2547 } else if (OP2_TYPE != IS_UNUSED) {
2548 char *function_name_strval = NULL;
2549 int function_name_strlen = 0;
2550 zend_free_op free_op2;
2551
2552 if (OP2_TYPE == IS_CONST) {
2553 function_name_strval = Z_STRVAL_P(opline->op2.zv);
2554 function_name_strlen = Z_STRLEN_P(opline->op2.zv);
2555 } else {
2556 function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
2557
2558 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
2559 if (UNEXPECTED(EG(exception) != NULL)) {
2560 HANDLE_EXCEPTION();
2561 }
2562 zend_error_noreturn(E_ERROR, "Function name must be a string");
2563 } else {
2564 function_name_strval = Z_STRVAL_P(function_name);
2565 function_name_strlen = Z_STRLEN_P(function_name);
2566 }
2567 }
2568
2569 if (function_name_strval) {
2570 if (ce->get_static_method) {
2571 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
2572 } else {
2573 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((OP2_TYPE == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
2574 }
2575 if (UNEXPECTED(call->fbc == NULL)) {
2576 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
2577 }
2578 if (OP2_TYPE == IS_CONST &&
2579 EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
2580 EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
2581 if (OP1_TYPE == IS_CONST) {
2582 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
2583 } else {
2584 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
2585 }
2586 }
2587 }
2588 if (OP2_TYPE != IS_CONST) {
2589 FREE_OP2();
2590 }
2591 } else {
2592 if (UNEXPECTED(ce->constructor == NULL)) {
2593 zend_error_noreturn(E_ERROR, "Cannot call constructor");
2594 }
2595 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
2596 zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
2597 }
2598 call->fbc = ce->constructor;
2599 }
2600
2601 if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
2602 call->object = NULL;
2603 } else {
2604 if (EG(This) &&
2605 Z_OBJ_HT_P(EG(This))->get_class_entry &&
2606 !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
2607
2608
2609 if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
2610 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);
2611 } else {
2612
2613 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);
2614 }
2615 }
2616 if ((call->object = EG(This))) {
2617 Z_ADDREF_P(call->object);
2618 call->called_scope = Z_OBJCE_P(call->object);
2619 }
2620 }
2621
2622 call->num_additional_args = 0;
2623 call->is_ctor_call = 0;
2624 EX(call) = call;
2625
2626 CHECK_EXCEPTION();
2627 ZEND_VM_NEXT_OPCODE();
2628 }
2629
2630 ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
2631 {
2632 USE_OPLINE
2633 zval *function_name;
2634 call_slot *call = EX(call_slots) + opline->result.num;
2635
2636 if (OP2_TYPE == IS_CONST) {
2637 function_name = (zval*)(opline->op2.literal+1);
2638 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
2639 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
2640 } 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)) {
2641 SAVE_OPLINE();
2642 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
2643 } else {
2644 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
2645 }
2646
2647 call->object = NULL;
2648 call->called_scope = NULL;
2649 call->num_additional_args = 0;
2650 call->is_ctor_call = 0;
2651 EX(call) = call;
2652
2653
2654 ZEND_VM_NEXT_OPCODE();
2655 } else {
2656 char *function_name_strval, *lcname;
2657 int function_name_strlen;
2658 zend_free_op free_op2;
2659
2660 SAVE_OPLINE();
2661 function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
2662
2663 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
2664 function_name_strval = Z_STRVAL_P(function_name);
2665 function_name_strlen = Z_STRLEN_P(function_name);
2666 if (function_name_strval[0] == '\\') {
2667 function_name_strlen -= 1;
2668 lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
2669 } else {
2670 lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
2671 }
2672 if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
2673 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
2674 }
2675 efree(lcname);
2676 FREE_OP2();
2677
2678 call->object = NULL;
2679 call->called_scope = NULL;
2680 call->num_additional_args = 0;
2681 call->is_ctor_call = 0;
2682 EX(call) = call;
2683
2684 CHECK_EXCEPTION();
2685 ZEND_VM_NEXT_OPCODE();
2686 } else if (OP2_TYPE != IS_CONST && OP2_TYPE != IS_TMP_VAR &&
2687 EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
2688 Z_OBJ_HANDLER_P(function_name, get_closure) &&
2689 Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
2690 if (call->object) {
2691 Z_ADDREF_P(call->object);
2692 }
2693 if (OP2_TYPE == IS_VAR && OP2_FREE && Z_REFCOUNT_P(function_name) == 1 &&
2694 call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
2695
2696 call->fbc->common.prototype = (zend_function*)function_name;
2697 } else {
2698 FREE_OP2();
2699 }
2700
2701 call->num_additional_args = 0;
2702 call->is_ctor_call = 0;
2703 EX(call) = call;
2704
2705 CHECK_EXCEPTION();
2706 ZEND_VM_NEXT_OPCODE();
2707 } else if (OP2_TYPE != IS_CONST &&
2708 EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
2709 zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
2710 zend_class_entry *ce;
2711 zval **method = NULL;
2712 zval **obj = NULL;
2713
2714 zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
2715 zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
2716
2717 if (!obj || !method) {
2718 zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
2719 }
2720
2721 if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
2722 zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
2723 }
2724
2725 if (Z_TYPE_PP(method) != IS_STRING) {
2726 zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
2727 }
2728
2729 if (Z_TYPE_PP(obj) == IS_STRING) {
2730 ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
2731 if (UNEXPECTED(ce == NULL)) {
2732 CHECK_EXCEPTION();
2733 ZEND_VM_NEXT_OPCODE();
2734 }
2735 call->called_scope = ce;
2736 call->object = NULL;
2737
2738 if (ce->get_static_method) {
2739 call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
2740 } else {
2741 call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
2742 }
2743 } else {
2744 call->object = *obj;
2745 ce = call->called_scope = Z_OBJCE_PP(obj);
2746
2747 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
2748 if (UNEXPECTED(call->fbc == NULL)) {
2749 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
2750 }
2751
2752 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
2753 call->object = NULL;
2754 } else {
2755 if (!PZVAL_IS_REF(call->object)) {
2756 Z_ADDREF_P(call->object);
2757 } else {
2758 zval *this_ptr;
2759 ALLOC_ZVAL(this_ptr);
2760 INIT_PZVAL_COPY(this_ptr, call->object);
2761 zval_copy_ctor(this_ptr);
2762 call->object = this_ptr;
2763 }
2764 }
2765 }
2766
2767 if (UNEXPECTED(call->fbc == NULL)) {
2768 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
2769 }
2770
2771 call->num_additional_args = 0;
2772 call->is_ctor_call = 0;
2773 EX(call) = call;
2774
2775 FREE_OP2();
2776 CHECK_EXCEPTION();
2777 ZEND_VM_NEXT_OPCODE();
2778 } else {
2779 if (UNEXPECTED(EG(exception) != NULL)) {
2780 HANDLE_EXCEPTION();
2781 }
2782 zend_error_noreturn(E_ERROR, "Function name must be a string");
2783 ZEND_VM_NEXT_OPCODE();
2784 }
2785 }
2786 }
2787
2788
2789 ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST)
2790 {
2791 USE_OPLINE
2792 zend_literal *func_name;
2793 call_slot *call = EX(call_slots) + opline->result.num;
2794
2795 func_name = opline->op2.literal + 1;
2796 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
2797 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
2798 } 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) {
2799 func_name++;
2800 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)) {
2801 SAVE_OPLINE();
2802 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
2803 } else {
2804 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
2805 }
2806 } else {
2807 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
2808 }
2809
2810 call->object = NULL;
2811 call->called_scope = NULL;
2812 call->num_additional_args = 0;
2813 call->is_ctor_call = 0;
2814
2815 EX(call) = call;
2816 ZEND_VM_NEXT_OPCODE();
2817 }
2818
2819 ZEND_VM_HANDLER(61, ZEND_DO_FCALL_BY_NAME, ANY, ANY)
2820 {
2821 EX(function_state).function = EX(call)->fbc;
2822 ZEND_VM_DISPATCH_TO_HELPER(zend_do_fcall_common_helper);
2823 }
2824
2825 ZEND_VM_HANDLER(60, ZEND_DO_FCALL, CONST, ANY)
2826 {
2827 USE_OPLINE
2828 zend_free_op free_op1;
2829 zval *fname = GET_OP1_ZVAL_PTR(BP_VAR_R);
2830 call_slot *call = EX(call_slots) + opline->op2.num;
2831
2832 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
2833 EX(function_state).function = CACHED_PTR(opline->op1.literal->cache_slot);
2834 } 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)) {
2835 SAVE_OPLINE();
2836 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
2837 } else {
2838 CACHE_PTR(opline->op1.literal->cache_slot, EX(function_state).function);
2839 }
2840
2841 call->fbc = EX(function_state).function;
2842 call->object = NULL;
2843 call->called_scope = NULL;
2844 call->num_additional_args = 0;
2845 call->is_ctor_call = 0;
2846 EX(call) = call;
2847
2848 FREE_OP1();
2849
2850 ZEND_VM_DISPATCH_TO_HELPER(zend_do_fcall_common_helper);
2851 }
2852
2853 ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
2854 {
2855 USE_OPLINE
2856 zval *retval_ptr;
2857 zend_free_op free_op1;
2858
2859 SAVE_OPLINE();
2860 retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
2861
2862 if (!EG(return_value_ptr_ptr)) {
2863 FREE_OP1();
2864 } else {
2865 if (OP1_TYPE == IS_CONST ||
2866 OP1_TYPE == IS_TMP_VAR ||
2867 PZVAL_IS_REF(retval_ptr)) {
2868 zval *ret;
2869
2870 ALLOC_ZVAL(ret);
2871 INIT_PZVAL_COPY(ret, retval_ptr);
2872 if (OP1_TYPE != IS_TMP_VAR) {
2873 zval_copy_ctor(ret);
2874 }
2875 *EG(return_value_ptr_ptr) = ret;
2876 FREE_OP1_IF_VAR();
2877 } else if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) &&
2878 retval_ptr == &EG(uninitialized_zval)) {
2879 zval *ret;
2880
2881 if (OP1_TYPE == IS_VAR) {
2882 Z_DELREF_P(retval_ptr);
2883 }
2884 ALLOC_INIT_ZVAL(ret);
2885 *EG(return_value_ptr_ptr) = ret;
2886 } else {
2887 *EG(return_value_ptr_ptr) = retval_ptr;
2888 if (OP1_TYPE == IS_CV) {
2889 Z_ADDREF_P(retval_ptr);
2890 }
2891 }
2892 }
2893 ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
2894 }
2895
2896 ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
2897 {
2898 USE_OPLINE
2899 zval *retval_ptr;
2900 zval **retval_ptr_ptr;
2901 zend_free_op free_op1;
2902
2903 SAVE_OPLINE();
2904
2905 do {
2906 if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR ||
2907 (OP1_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
2908
2909 zend_error(E_NOTICE, "Only variable references should be returned by reference");
2910
2911 retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
2912 if (!EG(return_value_ptr_ptr)) {
2913 if (OP1_TYPE == IS_TMP_VAR) {
2914 FREE_OP1();
2915 }
2916 } else if (!IS_OP1_TMP_FREE()) {
2917 zval *ret;
2918
2919 ALLOC_ZVAL(ret);
2920 INIT_PZVAL_COPY(ret, retval_ptr);
2921 zval_copy_ctor(ret);
2922 *EG(return_value_ptr_ptr) = ret;
2923 } else {
2924 zval *ret;
2925
2926 ALLOC_ZVAL(ret);
2927 INIT_PZVAL_COPY(ret, retval_ptr);
2928 *EG(return_value_ptr_ptr) = ret;
2929 }
2930 break;
2931 }
2932
2933 retval_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
2934
2935 if (OP1_TYPE == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
2936 zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
2937 }
2938
2939 if (OP1_TYPE == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
2940 if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
2941 EX_T(opline->op1.var).var.fcall_returned_reference) {
2942 } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
2943 zend_error(E_NOTICE, "Only variable references should be returned by reference");
2944 if (EG(return_value_ptr_ptr)) {
2945 zval *ret;
2946
2947 ALLOC_ZVAL(ret);
2948 INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
2949 zval_copy_ctor(ret);
2950 *EG(return_value_ptr_ptr) = ret;
2951 }
2952 break;
2953 }
2954 }
2955
2956 if (EG(return_value_ptr_ptr)) {
2957 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
2958 Z_ADDREF_PP(retval_ptr_ptr);
2959
2960 *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
2961 }
2962 } while (0);
2963
2964 FREE_OP1_VAR_PTR();
2965 ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
2966 }
2967
2968 ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, ANY, ANY)
2969 {
2970
2971 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
2972
2973
2974 zend_generator_close(generator, 1 TSRMLS_CC);
2975
2976
2977 ZEND_VM_RETURN();
2978 }
2979
2980 ZEND_VM_HANDLER(108, ZEND_THROW, CONST|TMP|VAR|CV, ANY)
2981 {
2982 USE_OPLINE
2983 zval *value;
2984 zval *exception;
2985 zend_free_op free_op1;
2986
2987 SAVE_OPLINE();
2988 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
2989
2990 if (OP1_TYPE == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
2991 if (UNEXPECTED(EG(exception) != NULL)) {
2992 HANDLE_EXCEPTION();
2993 }
2994 zend_error_noreturn(E_ERROR, "Can only throw objects");
2995 }
2996
2997 zend_exception_save(TSRMLS_C);
2998
2999 ALLOC_ZVAL(exception);
3000 INIT_PZVAL_COPY(exception, value);
3001 if (!IS_OP1_TMP_FREE()) {
3002 zval_copy_ctor(exception);
3003 }
3004
3005 zend_throw_exception_object(exception TSRMLS_CC);
3006 zend_exception_restore(TSRMLS_C);
3007 FREE_OP1_IF_VAR();
3008 HANDLE_EXCEPTION();
3009 }
3010
3011 ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV)
3012 {
3013 USE_OPLINE
3014 zend_class_entry *ce, *catch_ce;
3015 zval *exception;
3016
3017 SAVE_OPLINE();
3018
3019 zend_exception_restore(TSRMLS_C);
3020 if (EG(exception) == NULL) {
3021 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
3022 ZEND_VM_CONTINUE();
3023 }
3024 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
3025 catch_ce = CACHED_PTR(opline->op1.literal->cache_slot);
3026 } else {
3027 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);
3028
3029 CACHE_PTR(opline->op1.literal->cache_slot, catch_ce);
3030 }
3031 ce = Z_OBJCE_P(EG(exception));
3032
3033 #ifdef HAVE_DTRACE
3034 if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
3035 DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
3036 }
3037 #endif
3038
3039 if (ce != catch_ce) {
3040 if (!instanceof_function(ce, catch_ce TSRMLS_CC)) {
3041 if (opline->result.num) {
3042 zend_throw_exception_internal(NULL TSRMLS_CC);
3043 HANDLE_EXCEPTION();
3044 }
3045 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
3046 ZEND_VM_CONTINUE();
3047 }
3048 }
3049
3050 exception = EG(exception);
3051 if (!EG(active_symbol_table)) {
3052 if (EX_CV(opline->op2.var)) {
3053 zval_ptr_dtor(EX_CV(opline->op2.var));
3054 }
3055 EX_CV(opline->op2.var) = (zval**)EX_CV_NUM(execute_data, EX(op_array)->last_var + opline->op2.var);
3056 *EX_CV(opline->op2.var) = EG(exception);
3057 } else {
3058 zend_compiled_variable *cv = &CV_DEF_OF(opline->op2.var);
3059 zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value,
3060 &EG(exception), sizeof(zval *), (void**)&EX_CV(opline->op2.var));
3061 }
3062 if (UNEXPECTED(EG(exception) != exception)) {
3063 Z_ADDREF_P(EG(exception));
3064 HANDLE_EXCEPTION();
3065 } else {
3066 EG(exception) = NULL;
3067 ZEND_VM_NEXT_OPCODE();
3068 }
3069 }
3070
3071 ZEND_VM_HANDLER(65, ZEND_SEND_VAL, CONST|TMP, ANY)
3072 {
3073 USE_OPLINE
3074
3075 SAVE_OPLINE();
3076 if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
3077 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
3078 zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.num);
3079 }
3080 }
3081
3082 {
3083 zval *valptr;
3084 zval *value;
3085 zend_free_op free_op1;
3086
3087 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
3088
3089 ALLOC_ZVAL(valptr);
3090 INIT_PZVAL_COPY(valptr, value);
3091 if (!IS_OP1_TMP_FREE()) {
3092 zval_copy_ctor(valptr);
3093 }
3094 zend_vm_stack_push(valptr TSRMLS_CC);
3095 FREE_OP1_IF_VAR();
3096 }
3097 CHECK_EXCEPTION();
3098 ZEND_VM_NEXT_OPCODE();
3099 }
3100
3101 ZEND_VM_HELPER(zend_send_by_var_helper, VAR|CV, ANY)
3102 {
3103 USE_OPLINE
3104 zval *varptr;
3105 zend_free_op free_op1;
3106 varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
3107
3108 if (varptr == &EG(uninitialized_zval)) {
3109 if (OP1_TYPE == IS_VAR) {
3110 Z_DELREF_P(varptr);
3111 }
3112 ALLOC_INIT_ZVAL(varptr);
3113 } else if (PZVAL_IS_REF(varptr)) {
3114 if (OP1_TYPE == IS_CV ||
3115 (OP1_TYPE == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) {
3116 zval *original_var = varptr;
3117
3118 ALLOC_ZVAL(varptr);
3119 INIT_PZVAL_COPY(varptr, original_var);
3120 zval_copy_ctor(varptr);
3121 FREE_OP1();
3122 } else {
3123 Z_UNSET_ISREF_P(varptr);
3124 }
3125 } else if (OP1_TYPE == IS_CV) {
3126 Z_ADDREF_P(varptr);
3127 }
3128 zend_vm_stack_push(varptr TSRMLS_CC);
3129
3130 CHECK_EXCEPTION();
3131 ZEND_VM_NEXT_OPCODE();
3132 }
3133
3134 ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR|CV, ANY)
3135 {
3136 USE_OPLINE
3137 zend_free_op free_op1;
3138 zval *varptr;
3139
3140 SAVE_OPLINE();
3141 if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) {
3142 if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
3143 ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
3144 }
3145 } else {
3146 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
3147 ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
3148 }
3149 }
3150
3151 varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
3152 if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
3153 EX_T(opline->op1.var).var.fcall_returned_reference) &&
3154 varptr != &EG(uninitialized_zval) &&
3155 (PZVAL_IS_REF(varptr) || Z_REFCOUNT_P(varptr) == 1)) {
3156 Z_SET_ISREF_P(varptr);
3157 if (OP1_TYPE == IS_CV) {
3158 Z_ADDREF_P(varptr);
3159 }
3160 zend_vm_stack_push(varptr TSRMLS_CC);
3161 } else {
3162 zval *valptr;
3163
3164 if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
3165 !(opline->extended_value & ZEND_ARG_SEND_SILENT) :
3166 !ARG_MAY_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
3167 zend_error(E_STRICT, "Only variables should be passed by reference");
3168 }
3169 ALLOC_ZVAL(valptr);
3170 INIT_PZVAL_COPY(valptr, varptr);
3171 if (!IS_OP1_TMP_FREE()) {
3172 zval_copy_ctor(valptr);
3173 }
3174 FREE_OP1_IF_VAR();
3175 zend_vm_stack_push(valptr TSRMLS_CC);
3176 }
3177 CHECK_EXCEPTION();
3178 ZEND_VM_NEXT_OPCODE();
3179 }
3180
3181 ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, ANY)
3182 {
3183 USE_OPLINE
3184 zend_free_op free_op1;
3185 zval **varptr_ptr;
3186 zval *varptr;
3187
3188 SAVE_OPLINE();
3189 varptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
3190
3191 if (OP1_TYPE == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) {
3192 zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
3193 }
3194
3195 if (OP1_TYPE == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) {
3196 ALLOC_INIT_ZVAL(varptr);
3197 zend_vm_stack_push(varptr TSRMLS_CC);
3198 CHECK_EXCEPTION();
3199 ZEND_VM_NEXT_OPCODE();
3200 }
3201
3202 if (opline->extended_value == ZEND_DO_FCALL_BY_NAME &&
3203 EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
3204 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
3205 ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
3206 }
3207 }
3208
3209 SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
3210 varptr = *varptr_ptr;
3211 Z_ADDREF_P(varptr);
3212 zend_vm_stack_push(varptr TSRMLS_CC);
3213
3214 FREE_OP1_VAR_PTR();
3215 CHECK_EXCEPTION();
3216 ZEND_VM_NEXT_OPCODE();
3217 }
3218
3219 ZEND_VM_HANDLER(66, ZEND_SEND_VAR, VAR|CV, ANY)
3220 {
3221 USE_OPLINE
3222
3223 if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
3224 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
3225 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_REF);
3226 }
3227 }
3228 SAVE_OPLINE();
3229 ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
3230 }
3231
3232 ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
3233 {
3234 USE_OPLINE
3235 zend_free_op free_op1;
3236 zval *args;
3237 int arg_num;
3238 SAVE_OPLINE();
3239
3240 args = GET_OP1_ZVAL_PTR(BP_VAR_R);
3241 arg_num = opline->op2.num + EX(call)->num_additional_args + 1;
3242
3243 switch (Z_TYPE_P(args)) {
3244 case IS_ARRAY: {
3245 HashTable *ht = Z_ARRVAL_P(args);
3246 HashPosition pos;
3247 zval **arg_ptr, *arg;
3248
3249 ZEND_VM_STACK_GROW_IF_NEEDED(zend_hash_num_elements(ht));
3250
3251 for (zend_hash_internal_pointer_reset_ex(ht, &pos);
3252 zend_hash_get_current_data_ex(ht, (void **) &arg_ptr, &pos) == SUCCESS;
3253 zend_hash_move_forward_ex(ht, &pos), ++arg_num
3254 ) {
3255 char *name;
3256 zend_uint name_len;
3257 zend_ulong index;
3258
3259 if (zend_hash_get_current_key_ex(ht, &name, &name_len, &index, 0, &pos) == HASH_KEY_IS_STRING) {
3260 zend_error(E_RECOVERABLE_ERROR, "Cannot unpack array with string keys");
3261 FREE_OP1();
3262 CHECK_EXCEPTION();
3263 ZEND_VM_NEXT_OPCODE();
3264 }
3265
3266 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
3267 SEPARATE_ZVAL_TO_MAKE_IS_REF(arg_ptr);
3268 arg = *arg_ptr;
3269 Z_ADDREF_P(arg);
3270 } else if (Z_ISREF_PP(arg_ptr)) {
3271 ALLOC_ZVAL(arg);
3272 MAKE_COPY_ZVAL(arg_ptr, arg);
3273 } else {
3274 arg = *arg_ptr;
3275 Z_ADDREF_P(arg);
3276 }
3277
3278 zend_vm_stack_push(arg TSRMLS_CC);
3279 EX(call)->num_additional_args++;
3280 }
3281 break;
3282 }
3283 case IS_OBJECT: {
3284 zend_class_entry *ce = Z_OBJCE_P(args);
3285 zend_object_iterator *iter;
3286
3287 if (!ce || !ce->get_iterator) {
3288 zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
3289 break;
3290 }
3291
3292 iter = ce->get_iterator(ce, args, 0 TSRMLS_CC);
3293 if (UNEXPECTED(!iter)) {
3294 FREE_OP1();
3295 if (!EG(exception)) {
3296 zend_throw_exception_ex(
3297 NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name
3298 );
3299 }
3300 HANDLE_EXCEPTION();
3301 }
3302
3303 if (iter->funcs->rewind) {
3304 iter->funcs->rewind(iter TSRMLS_CC);
3305 if (UNEXPECTED(EG(exception) != NULL)) {
3306 ZEND_VM_C_GOTO(unpack_iter_dtor);
3307 }
3308 }
3309
3310 for (; iter->funcs->valid(iter TSRMLS_CC) == SUCCESS; ++arg_num) {
3311 zval **arg_ptr, *arg;
3312
3313 if (UNEXPECTED(EG(exception) != NULL)) {
3314 ZEND_VM_C_GOTO(unpack_iter_dtor);
3315 }
3316
3317 iter->funcs->get_current_data(iter, &arg_ptr TSRMLS_CC);
3318 if (UNEXPECTED(EG(exception) != NULL)) {
3319 ZEND_VM_C_GOTO(unpack_iter_dtor);
3320 }
3321
3322 if (iter->funcs->get_current_key) {
3323 zval key;
3324 iter->funcs->get_current_key(iter, &key TSRMLS_CC);
3325 if (UNEXPECTED(EG(exception) != NULL)) {
3326 ZEND_VM_C_GOTO(unpack_iter_dtor);
3327 }
3328
3329 if (Z_TYPE(key) == IS_STRING) {
3330 zend_error(E_RECOVERABLE_ERROR,
3331 "Cannot unpack Traversable with string keys");
3332 zval_dtor(&key);
3333 ZEND_VM_C_GOTO(unpack_iter_dtor);
3334 }
3335
3336 zval_dtor(&key);
3337 }
3338
3339 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
3340 zend_error(
3341 E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
3342 " by unpacking a Traversable, passing by-value instead", arg_num,
3343 EX(call)->fbc->common.scope ? EX(call)->fbc->common.scope->name : "",
3344 EX(call)->fbc->common.scope ? "::" : "",
3345 EX(call)->fbc->common.function_name
3346 );
3347 }
3348
3349 if (Z_ISREF_PP(arg_ptr)) {
3350 ALLOC_ZVAL(arg);
3351 MAKE_COPY_ZVAL(arg_ptr, arg);
3352 } else {
3353 arg = *arg_ptr;
3354 Z_ADDREF_P(arg);
3355 }
3356
3357 ZEND_VM_STACK_GROW_IF_NEEDED(1);
3358 zend_vm_stack_push(arg TSRMLS_CC);
3359 EX(call)->num_additional_args++;
3360
3361 iter->funcs->move_forward(iter TSRMLS_CC);
3362 if (UNEXPECTED(EG(exception) != NULL)) {
3363 ZEND_VM_C_GOTO(unpack_iter_dtor);
3364 }
3365 }
3366
3367 ZEND_VM_C_LABEL(unpack_iter_dtor):
3368 iter->funcs->dtor(iter TSRMLS_CC);
3369 break;
3370 }
3371 default:
3372 zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
3373 }
3374
3375 FREE_OP1();
3376 CHECK_EXCEPTION();
3377 ZEND_VM_NEXT_OPCODE();
3378 }
3379
3380 ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
3381 {
3382 USE_OPLINE
3383 zend_uint arg_num = opline->op1.num;
3384 zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
3385
3386 SAVE_OPLINE();
3387 if (UNEXPECTED(param == NULL)) {
3388 if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value, NULL TSRMLS_CC)) {
3389 const char *space;
3390 const char *class_name;
3391 zend_execute_data *ptr;
3392
3393 if (EG(active_op_array)->scope) {
3394 class_name = EG(active_op_array)->scope->name;
3395 space = "::";
3396 } else {
3397 class_name = space = "";
3398 }
3399 ptr = EX(prev_execute_data);
3400
3401 if(ptr && ptr->op_array) {
3402 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);
3403 } else {
3404 zend_error(E_WARNING, "Missing argument %u for %s%s%s()", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C));
3405 }
3406 }
3407 } else {
3408 zval **var_ptr;
3409
3410 zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value, NULL TSRMLS_CC);
3411 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
3412 Z_DELREF_PP(var_ptr);
3413 *var_ptr = *param;
3414 Z_ADDREF_PP(var_ptr);
3415 }
3416
3417 CHECK_EXCEPTION();
3418 ZEND_VM_NEXT_OPCODE();
3419 }
3420
3421 ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST)
3422 {
3423 USE_OPLINE
3424 zval *assignment_value;
3425 zend_uint arg_num = opline->op1.num;
3426 zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
3427 zval **var_ptr;
3428
3429 SAVE_OPLINE();
3430 if (param == NULL) {
3431 ALLOC_ZVAL(assignment_value);
3432 *assignment_value = *opline->op2.zv;
3433 if (IS_CONSTANT_TYPE(Z_TYPE_P(assignment_value))) {
3434 Z_SET_REFCOUNT_P(assignment_value, 1);
3435 zval_update_constant(&assignment_value, 0 TSRMLS_CC);
3436 } else if (Z_TYPE_P(assignment_value) == IS_ARRAY) {
3437 HashTable *ht;
3438
3439 ALLOC_HASHTABLE(ht);
3440 zend_hash_init(ht, zend_hash_num_elements(Z_ARRVAL_P(assignment_value)), NULL, ZVAL_PTR_DTOR, 0);
3441 zend_hash_copy(ht, Z_ARRVAL_P(assignment_value), (copy_ctor_func_t) zval_deep_copy, NULL, sizeof(zval *));
3442 Z_ARRVAL_P(assignment_value) = ht;
3443 } else {
3444 zval_copy_ctor(assignment_value);
3445 }
3446 INIT_PZVAL(assignment_value);
3447 } else {
3448 assignment_value = *param;
3449 Z_ADDREF_P(assignment_value);
3450 }
3451
3452 zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value, opline->extended_value, opline->op2.zv TSRMLS_CC);
3453 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
3454 zval_ptr_dtor(var_ptr);
3455 *var_ptr = assignment_value;
3456
3457 CHECK_EXCEPTION();
3458 ZEND_VM_NEXT_OPCODE();
3459 }
3460
3461 ZEND_VM_HANDLER(164, ZEND_RECV_VARIADIC, ANY, ANY)
3462 {
3463 USE_OPLINE
3464 zend_uint arg_num = opline->op1.num;
3465 zend_uint arg_count = zend_vm_stack_get_args_count(TSRMLS_C);
3466 zval **var_ptr, *params;
3467
3468 SAVE_OPLINE();
3469
3470 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
3471 Z_DELREF_PP(var_ptr);
3472 MAKE_STD_ZVAL(params);
3473 *var_ptr = params;
3474
3475 if (arg_num <= arg_count) {
3476 array_init_size(params, arg_count - arg_num + 1);
3477 } else {
3478 array_init(params);
3479 }
3480
3481 for (; arg_num <= arg_count; ++arg_num) {
3482 zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
3483 zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value, NULL TSRMLS_CC);
3484 zend_hash_next_index_insert(Z_ARRVAL_P(params), param, sizeof(zval *), NULL);
3485 Z_ADDREF_PP(param);
3486 }
3487
3488 CHECK_EXCEPTION();
3489 ZEND_VM_NEXT_OPCODE();
3490 }
3491
3492 ZEND_VM_HANDLER(52, ZEND_BOOL, CONST|TMP|VAR|CV, ANY)
3493 {
3494 USE_OPLINE
3495 zend_free_op free_op1;
3496 zval *retval = &EX_T(opline->result.var).tmp_var;
3497
3498 SAVE_OPLINE();
3499
3500 ZVAL_BOOL(retval, i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R)));
3501 FREE_OP1();
3502
3503 CHECK_EXCEPTION();
3504 ZEND_VM_NEXT_OPCODE();
3505 }
3506
3507 ZEND_VM_HANDLER(50, ZEND_BRK, ANY, CONST)
3508 {
3509 USE_OPLINE
3510 zend_brk_cont_element *el;
3511
3512 SAVE_OPLINE();
3513 el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num,
3514 EX(op_array), execute_data TSRMLS_CC);
3515 ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
3516 }
3517
3518 ZEND_VM_HANDLER(51, ZEND_CONT, ANY, CONST)
3519 {
3520 USE_OPLINE
3521 zend_brk_cont_element *el;
3522
3523 SAVE_OPLINE();
3524 el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num,
3525 EX(op_array), execute_data TSRMLS_CC);
3526 ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
3527 }
3528
3529 ZEND_VM_HANDLER(100, ZEND_GOTO, ANY, CONST)
3530 {
3531 zend_op *brk_opline;
3532 USE_OPLINE
3533 zend_brk_cont_element *el;
3534
3535 SAVE_OPLINE();
3536 el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->extended_value,
3537 EX(op_array), execute_data TSRMLS_CC);
3538
3539 brk_opline = EX(op_array)->opcodes + el->brk;
3540
3541 switch (brk_opline->opcode) {
3542 case ZEND_SWITCH_FREE:
3543 if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
3544 zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
3545 }
3546 break;
3547 case ZEND_FREE:
3548 if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
3549 zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
3550 }
3551 break;
3552 }
3553 ZEND_VM_JMP(opline->op1.jmp_addr);
3554 }
3555
3556 ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
3557 {
3558 USE_OPLINE
3559 zend_free_op free_op1, free_op2;
3560
3561 SAVE_OPLINE();
3562 is_equal_function(&EX_T(opline->result.var).tmp_var,
3563 GET_OP1_ZVAL_PTR(BP_VAR_R),
3564 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
3565
3566 FREE_OP2();
3567 CHECK_EXCEPTION();
3568 ZEND_VM_NEXT_OPCODE();
3569 }
3570
3571 ZEND_VM_HANDLER(49, ZEND_SWITCH_FREE, VAR, ANY)
3572 {
3573 USE_OPLINE
3574
3575 SAVE_OPLINE();
3576 zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
3577 CHECK_EXCEPTION();
3578 ZEND_VM_NEXT_OPCODE();
3579 }
3580
3581 ZEND_VM_HANDLER(68, ZEND_NEW, ANY, ANY)
3582 {
3583 USE_OPLINE
3584 zval *object_zval;
3585 zend_function *constructor;
3586
3587 SAVE_OPLINE();
3588 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)) {
3589 if (EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
3590 zend_error_noreturn(E_ERROR, "Cannot instantiate interface %s", EX_T(opline->op1.var).class_entry->name);
3591 } else if ((EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
3592 zend_error_noreturn(E_ERROR, "Cannot instantiate trait %s", EX_T(opline->op1.var).class_entry->name);
3593 } else {
3594 zend_error_noreturn(E_ERROR, "Cannot instantiate abstract class %s", EX_T(opline->op1.var).class_entry->name);
3595 }
3596 }
3597 ALLOC_ZVAL(object_zval);
3598 object_init_ex(object_zval, EX_T(opline->op1.var).class_entry);
3599 INIT_PZVAL(object_zval);
3600
3601 constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
3602
3603 if (constructor == NULL) {
3604 if (RETURN_VALUE_USED(opline)) {
3605 AI_SET_PTR(&EX_T(opline->result.var), object_zval);
3606 } else {
3607 zval_ptr_dtor(&object_zval);
3608 }
3609 ZEND_VM_JMP(EX(op_array)->opcodes + opline->op2.opline_num);
3610 } else {
3611 call_slot *call = EX(call_slots) + opline->extended_value;
3612
3613 if (RETURN_VALUE_USED(opline)) {
3614 PZVAL_LOCK(object_zval);
3615 AI_SET_PTR(&EX_T(opline->result.var), object_zval);
3616 }
3617
3618
3619 call->fbc = constructor;
3620 call->object = object_zval;
3621 call->called_scope = EX_T(opline->op1.var).class_entry;
3622 call->num_additional_args = 0;
3623 call->is_ctor_call = 1;
3624 call->is_ctor_result_used = RETURN_VALUE_USED(opline);
3625 EX(call) = call;
3626
3627 CHECK_EXCEPTION();
3628 ZEND_VM_NEXT_OPCODE();
3629 }
3630 }
3631
3632 ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
3633 {
3634 USE_OPLINE
3635 zend_free_op free_op1;
3636 zval *obj;
3637 zend_class_entry *ce;
3638 zend_function *clone;
3639 zend_object_clone_obj_t clone_call;
3640
3641 SAVE_OPLINE();
3642 obj = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
3643
3644 if (OP1_TYPE == IS_CONST ||
3645 UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
3646 if (UNEXPECTED(EG(exception) != NULL)) {
3647 HANDLE_EXCEPTION();
3648 }
3649 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
3650 }
3651
3652 ce = Z_OBJCE_P(obj);
3653 clone = ce ? ce->clone : NULL;
3654 clone_call = Z_OBJ_HT_P(obj)->clone_obj;
3655 if (UNEXPECTED(clone_call == NULL)) {
3656 if (ce) {
3657 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
3658 } else {
3659 zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
3660 }
3661 }
3662
3663 if (ce && clone) {
3664 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
3665
3666
3667 if (UNEXPECTED(ce != EG(scope))) {
3668 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
3669 }
3670 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
3671
3672
3673 if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
3674 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
3675 }
3676 }
3677 }
3678
3679 if (EXPECTED(EG(exception) == NULL)) {
3680 zval *retval;
3681
3682 ALLOC_ZVAL(retval);
3683 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
3684 Z_TYPE_P(retval) = IS_OBJECT;
3685 Z_SET_REFCOUNT_P(retval, 1);
3686 Z_SET_ISREF_P(retval);
3687 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
3688 zval_ptr_dtor(&retval);
3689 } else {
3690 EX_T(opline->result.var).var.ptr = retval;
3691 }
3692 }
3693 FREE_OP1_IF_VAR();
3694 CHECK_EXCEPTION();
3695 ZEND_VM_NEXT_OPCODE();
3696 }
3697
3698 ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
3699 {
3700 USE_OPLINE
3701
3702 SAVE_OPLINE();
3703 if (OP1_TYPE == IS_UNUSED) {
3704 zend_constant *c;
3705 zval *retval;
3706
3707 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
3708 c = CACHED_PTR(opline->op2.literal->cache_slot);
3709 } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
3710 if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
3711 char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
3712 if(!actual) {
3713 actual = Z_STRVAL_P(opline->op2.zv);
3714 } else {
3715 actual++;
3716 }
3717
3718 zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
3719 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
3720 CHECK_EXCEPTION();
3721 ZEND_VM_NEXT_OPCODE();
3722 } else {
3723 zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
3724 }
3725 } else {
3726 CACHE_PTR(opline->op2.literal->cache_slot, c);
3727 }
3728 retval = &EX_T(opline->result.var).tmp_var;
3729 ZVAL_COPY_VALUE(retval, &c->value);
3730 zval_copy_ctor(retval);
3731 } else {
3732
3733 zend_class_entry *ce;
3734 zval **value;
3735
3736 if (OP1_TYPE == IS_CONST) {
3737 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
3738 value = CACHED_PTR(opline->op2.literal->cache_slot);
3739 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
3740 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
3741 goto constant_fetch_end;
3742 } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
3743 ce = CACHED_PTR(opline->op1.literal->cache_slot);
3744 } else {
3745 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);
3746 if (UNEXPECTED(EG(exception) != NULL)) {
3747 HANDLE_EXCEPTION();
3748 }
3749 if (UNEXPECTED(ce == NULL)) {
3750 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
3751 }
3752 CACHE_PTR(opline->op1.literal->cache_slot, ce);
3753 }
3754 } else {
3755 ce = EX_T(opline->op1.var).class_entry;
3756 if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
3757 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
3758 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
3759 goto constant_fetch_end;
3760 }
3761 }
3762
3763 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)) {
3764 if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
3765 zend_class_entry *old_scope = EG(scope);
3766
3767 EG(scope) = ce;
3768 zval_update_constant(value, 1 TSRMLS_CC);
3769 EG(scope) = old_scope;
3770 }
3771 if (OP1_TYPE == IS_CONST) {
3772 CACHE_PTR(opline->op2.literal->cache_slot, value);
3773 } else {
3774 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
3775 }
3776 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
3777 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
3778 } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
3779
3780 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
3781 } else {
3782 zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
3783 }
3784 }
3785 constant_fetch_end:
3786 CHECK_EXCEPTION();
3787 ZEND_VM_NEXT_OPCODE();
3788 }
3789
3790 ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUSED|CV)
3791 {
3792 USE_OPLINE
3793 zend_free_op free_op1;
3794 zval *expr_ptr;
3795
3796 SAVE_OPLINE();
3797 if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && opline->extended_value) {
3798 zval **expr_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
3799
3800 if (OP1_TYPE == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
3801 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
3802 }
3803 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
3804 expr_ptr = *expr_ptr_ptr;
3805 Z_ADDREF_P(expr_ptr);
3806 } else {
3807 expr_ptr=GET_OP1_ZVAL_PTR(BP_VAR_R);
3808 if (IS_OP1_TMP_FREE()) {
3809 zval *new_expr;
3810
3811 ALLOC_ZVAL(new_expr);
3812 INIT_PZVAL_COPY(new_expr, expr_ptr);
3813 expr_ptr = new_expr;
3814 } else if (OP1_TYPE == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
3815 zval *new_expr;
3816
3817 ALLOC_ZVAL(new_expr);
3818 INIT_PZVAL_COPY(new_expr, expr_ptr);
3819 expr_ptr = new_expr;
3820 zendi_zval_copy_ctor(*expr_ptr);
3821 FREE_OP1_IF_VAR();
3822 } else if (OP1_TYPE == IS_CV) {
3823 Z_ADDREF_P(expr_ptr);
3824 }
3825 }
3826
3827 if (OP2_TYPE != IS_UNUSED) {
3828 zend_free_op free_op2;
3829 zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
3830 ulong hval;
3831
3832 switch (Z_TYPE_P(offset)) {
3833 case IS_DOUBLE:
3834 hval = zend_dval_to_lval(Z_DVAL_P(offset));
3835 ZEND_VM_C_GOTO(num_index);
3836 case IS_LONG:
3837 case IS_BOOL:
3838 hval = Z_LVAL_P(offset);
3839 ZEND_VM_C_LABEL(num_index):
3840 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
3841 break;
3842 case IS_STRING:
3843 if (OP2_TYPE == IS_CONST) {
3844 hval = Z_HASH_P(offset);
3845 } else {
3846 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index));
3847 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
3848 }
3849 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);
3850 break;
3851 case IS_NULL:
3852 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
3853 break;
3854 default:
3855 zend_error(E_WARNING, "Illegal offset type");
3856 zval_ptr_dtor(&expr_ptr);
3857
3858 break;
3859 }
3860 FREE_OP2();
3861 } else {
3862 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
3863 }
3864 if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && opline->extended_value) {
3865 FREE_OP1_VAR_PTR();
3866 }
3867 CHECK_EXCEPTION();
3868 ZEND_VM_NEXT_OPCODE();
3869 }
3870
3871 ZEND_VM_HANDLER(71, ZEND_INIT_ARRAY, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
3872 {
3873 USE_OPLINE
3874
3875 array_init(&EX_T(opline->result.var).tmp_var);
3876 if (OP1_TYPE == IS_UNUSED) {
3877 ZEND_VM_NEXT_OPCODE();
3878 #if !defined(ZEND_VM_SPEC) || OP1_TYPE != IS_UNUSED
3879 } else {
3880 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ADD_ARRAY_ELEMENT);
3881 #endif
3882 }
3883 }
3884
3885 ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)
3886 {
3887 USE_OPLINE
3888 zend_free_op free_op1;
3889 zval *expr;
3890 zval *result = &EX_T(opline->result.var).tmp_var;
3891
3892 SAVE_OPLINE();
3893 expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
3894
3895 if (opline->extended_value != IS_STRING) {
3896 ZVAL_COPY_VALUE(result, expr);
3897 if (!IS_OP1_TMP_FREE()) {
3898 zendi_zval_copy_ctor(*result);
3899 }
3900 }
3901 switch (opline->extended_value) {
3902 case IS_NULL:
3903 convert_to_null(result);
3904 break;
3905 case IS_BOOL:
3906 convert_to_boolean(result);
3907 break;
3908 case IS_LONG:
3909 convert_to_long(result);
3910 break;
3911 case IS_DOUBLE:
3912 convert_to_double(result);
3913 break;
3914 case IS_STRING: {
3915 zval var_copy;
3916 int use_copy;
3917
3918 zend_make_printable_zval(expr, &var_copy, &use_copy);
3919 if (use_copy) {
3920 ZVAL_COPY_VALUE(result, &var_copy);
3921 if (IS_OP1_TMP_FREE()) {
3922 FREE_OP1();
3923 }
3924 } else {
3925 ZVAL_COPY_VALUE(result, expr);
3926 if (!IS_OP1_TMP_FREE()) {
3927 zendi_zval_copy_ctor(*result);
3928 }
3929 }
3930 break;
3931 }
3932 case IS_ARRAY:
3933 convert_to_array(result);
3934 break;
3935 case IS_OBJECT:
3936 convert_to_object(result);
3937 break;
3938 }
3939 FREE_OP1_IF_VAR();
3940 CHECK_EXCEPTION();
3941 ZEND_VM_NEXT_OPCODE();
3942 }
3943
3944 ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
3945 {
3946 USE_OPLINE
3947 zend_op_array *new_op_array=NULL;
3948 zend_free_op free_op1;
3949 zval *inc_filename;
3950 zval *tmp_inc_filename = NULL;
3951 zend_bool failure_retval=0;
3952
3953 SAVE_OPLINE();
3954 inc_filename = GET_OP1_ZVAL_PTR(BP_VAR_R);
3955
3956 if (inc_filename->type!=IS_STRING) {
3957 MAKE_STD_ZVAL(tmp_inc_filename);
3958 ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
3959 zval_copy_ctor(tmp_inc_filename);
3960 convert_to_string(tmp_inc_filename);
3961 inc_filename = tmp_inc_filename;
3962 }
3963
3964 if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
3965 if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
3966 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
3967 } else {
3968 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
3969 }
3970 } else {
3971 switch (opline->extended_value) {
3972 case ZEND_INCLUDE_ONCE:
3973 case ZEND_REQUIRE_ONCE: {
3974 zend_file_handle file_handle;
3975 char *resolved_path;
3976
3977 resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
3978 if (resolved_path) {
3979 failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
3980 } else {
3981 resolved_path = Z_STRVAL_P(inc_filename);
3982 }
3983
3984 if (failure_retval) {
3985
3986 } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
3987
3988 if (!file_handle.opened_path) {
3989 file_handle.opened_path = estrdup(resolved_path);
3990 }
3991
3992 if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
3993 new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
3994 zend_destroy_file_handle(&file_handle TSRMLS_CC);
3995 } else {
3996 zend_file_handle_dtor(&file_handle TSRMLS_CC);
3997 failure_retval=1;
3998 }
3999 } else {
4000 if (opline->extended_value == ZEND_INCLUDE_ONCE) {
4001 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
4002 } else {
4003 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
4004 }
4005 }
4006 if (resolved_path != Z_STRVAL_P(inc_filename)) {
4007 efree(resolved_path);
4008 }
4009 }
4010 break;
4011 case ZEND_INCLUDE:
4012 case ZEND_REQUIRE:
4013 new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC);
4014 break;
4015 case ZEND_EVAL: {
4016 char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
4017
4018 new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
4019 efree(eval_desc);
4020 }
4021 break;
4022 EMPTY_SWITCH_DEFAULT_CASE()
4023 }
4024 }
4025 if (tmp_inc_filename) {
4026 zval_ptr_dtor(&tmp_inc_filename);
4027 }
4028 FREE_OP1();
4029 if (UNEXPECTED(EG(exception) != NULL)) {
4030 HANDLE_EXCEPTION();
4031 } else if (EXPECTED(new_op_array != NULL)) {
4032 EX(original_return_value) = EG(return_value_ptr_ptr);
4033 EG(active_op_array) = new_op_array;
4034 if (RETURN_VALUE_USED(opline)) {
4035 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
4036 EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
4037 } else {
4038 EG(return_value_ptr_ptr) = NULL;
4039 }
4040
4041 EX(function_state).function = (zend_function *) new_op_array;
4042 EX(object) = NULL;
4043
4044 if (!EG(active_symbol_table)) {
4045 zend_rebuild_symbol_table(TSRMLS_C);
4046 }
4047
4048 if (EXPECTED(zend_execute_ex == execute_ex)) {
4049 ZEND_VM_ENTER();
4050 } else {
4051 zend_execute(new_op_array TSRMLS_CC);
4052 }
4053
4054 EX(function_state).function = (zend_function *) EX(op_array);
4055
4056 EG(opline_ptr) = &EX(opline);
4057 EG(active_op_array) = EX(op_array);
4058 EG(return_value_ptr_ptr) = EX(original_return_value);
4059 destroy_op_array(new_op_array TSRMLS_CC);
4060 efree(new_op_array);
4061 if (UNEXPECTED(EG(exception) != NULL)) {
4062 zend_throw_exception_internal(NULL TSRMLS_CC);
4063 HANDLE_EXCEPTION();
4064 }
4065
4066 } else if (RETURN_VALUE_USED(opline)) {
4067 zval *retval;
4068
4069 ALLOC_ZVAL(retval);
4070 ZVAL_BOOL(retval, failure_retval);
4071 INIT_PZVAL(retval);
4072 EX_T(opline->result.var).var.ptr = retval;
4073 }
4074 ZEND_VM_NEXT_OPCODE();
4075 }
4076
4077 ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
4078 {
4079 USE_OPLINE
4080 zval tmp, *varname;
4081 HashTable *target_symbol_table;
4082 zend_free_op free_op1;
4083
4084 SAVE_OPLINE();
4085 if (OP1_TYPE == IS_CV &&
4086 OP2_TYPE == IS_UNUSED &&
4087 (opline->extended_value & ZEND_QUICK_SET)) {
4088 if (EG(active_symbol_table)) {
4089 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
4090
4091 zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
4092 EX_CV(opline->op1.var) = NULL;
4093 } else if (EX_CV(opline->op1.var)) {
4094 zval_ptr_dtor(EX_CV(opline->op1.var));
4095 EX_CV(opline->op1.var) = NULL;
4096 }
4097 CHECK_EXCEPTION();
4098 ZEND_VM_NEXT_OPCODE();
4099 }
4100
4101 varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
4102
4103 if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
4104 ZVAL_COPY_VALUE(&tmp, varname);
4105 zval_copy_ctor(&tmp);
4106 convert_to_string(&tmp);
4107 varname = &tmp;
4108 } else if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
4109 Z_ADDREF_P(varname);
4110 }
4111
4112 if (OP2_TYPE != IS_UNUSED) {
4113 zend_class_entry *ce;
4114
4115 if (OP2_TYPE == IS_CONST) {
4116 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
4117 ce = CACHED_PTR(opline->op2.literal->cache_slot);
4118 } else {
4119 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);
4120 if (UNEXPECTED(EG(exception) != NULL)) {
4121 if (OP1_TYPE != IS_CONST && varname == &tmp) {
4122 zval_dtor(&tmp);
4123 } else if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
4124 zval_ptr_dtor(&varname);
4125 }
4126 FREE_OP1();
4127 HANDLE_EXCEPTION();
4128 }
4129 if (UNEXPECTED(ce == NULL)) {
4130 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
4131 }
4132 CACHE_PTR(opline->op2.literal->cache_slot, ce);
4133 }
4134 } else {
4135 ce = EX_T(opline->op2.var).class_entry;
4136 }
4137 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
4138 } else {
4139 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
4140
4141 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
4142 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
4143 }
4144
4145 if (OP1_TYPE != IS_CONST && varname == &tmp) {
4146 zval_dtor(&tmp);
4147 } else if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
4148 zval_ptr_dtor(&varname);
4149 }
4150 FREE_OP1();
4151 CHECK_EXCEPTION();
4152 ZEND_VM_NEXT_OPCODE();
4153 }
4154
4155 ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
4156 {
4157 USE_OPLINE
4158 zend_free_op free_op1, free_op2;
4159 zval **container;
4160 zval *offset;
4161 ulong hval;
4162
4163 SAVE_OPLINE();
4164 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
4165 if (OP1_TYPE == IS_CV && container != &EG(uninitialized_zval_ptr)) {
4166 SEPARATE_ZVAL_IF_NOT_REF(container);
4167 }
4168 offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
4169
4170 if (OP1_TYPE != IS_VAR || container) {
4171 switch (Z_TYPE_PP(container)) {
4172 case IS_ARRAY: {
4173 HashTable *ht = Z_ARRVAL_PP(container);
4174
4175 switch (Z_TYPE_P(offset)) {
4176 case IS_DOUBLE:
4177 hval = zend_dval_to_lval(Z_DVAL_P(offset));
4178 zend_hash_index_del(ht, hval);
4179 break;
4180 case IS_RESOURCE:
4181 case IS_BOOL:
4182 case IS_LONG:
4183 hval = Z_LVAL_P(offset);
4184 zend_hash_index_del(ht, hval);
4185 break;
4186 case IS_STRING:
4187 if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
4188 Z_ADDREF_P(offset);
4189 }
4190 if (OP2_TYPE == IS_CONST) {
4191 hval = Z_HASH_P(offset);
4192 } else {
4193 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index_dim));
4194 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
4195 }
4196 if (ht == &EG(symbol_table)) {
4197 zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
4198 } else {
4199 zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
4200 }
4201 if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
4202 zval_ptr_dtor(&offset);
4203 }
4204 break;
4205 ZEND_VM_C_LABEL(num_index_dim):
4206 zend_hash_index_del(ht, hval);
4207 if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
4208 zval_ptr_dtor(&offset);
4209 }
4210 break;
4211 case IS_NULL:
4212 zend_hash_del(ht, "", sizeof(""));
4213 break;
4214 default:
4215 zend_error(E_WARNING, "Illegal offset type in unset");
4216 break;
4217 }
4218 FREE_OP2();
4219 break;
4220 }
4221 case IS_OBJECT:
4222 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
4223 zend_error_noreturn(E_ERROR, "Cannot use object as array");
4224 }
4225 if (IS_OP2_TMP_FREE()) {
4226 MAKE_REAL_ZVAL_PTR(offset);
4227 }
4228 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
4229 if (IS_OP2_TMP_FREE()) {
4230 zval_ptr_dtor(&offset);
4231 } else {
4232 FREE_OP2();
4233 }
4234 break;
4235 case IS_STRING:
4236 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
4237 ZEND_VM_CONTINUE();
4238 default:
4239 FREE_OP2();
4240 break;
4241 }
4242 } else {
4243 FREE_OP2();
4244 }
4245 FREE_OP1_VAR_PTR();
4246
4247 CHECK_EXCEPTION();
4248 ZEND_VM_NEXT_OPCODE();
4249 }
4250
4251 ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
4252 {
4253 USE_OPLINE
4254 zend_free_op free_op1, free_op2;
4255 zval **container;
4256 zval *offset;
4257
4258 SAVE_OPLINE();
4259 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
4260 offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
4261
4262 if (OP1_TYPE != IS_VAR || container) {
4263 if (OP1_TYPE == IS_CV && container != &EG(uninitialized_zval_ptr)) {
4264 SEPARATE_ZVAL_IF_NOT_REF(container);
4265 }
4266 if (Z_TYPE_PP(container) == IS_OBJECT) {
4267 if (IS_OP2_TMP_FREE()) {
4268 MAKE_REAL_ZVAL_PTR(offset);
4269 }
4270 if (Z_OBJ_HT_P(*container)->unset_property) {
4271 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
4272 } else {
4273 zend_error(E_NOTICE, "Trying to unset property of non-object");
4274 }
4275 if (IS_OP2_TMP_FREE()) {
4276 zval_ptr_dtor(&offset);
4277 } else {
4278 FREE_OP2();
4279 }
4280 } else {
4281 FREE_OP2();
4282 }
4283 } else {
4284 FREE_OP2();
4285 }
4286 FREE_OP1_VAR_PTR();
4287
4288 CHECK_EXCEPTION();
4289 ZEND_VM_NEXT_OPCODE();
4290 }
4291
4292 ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
4293 {
4294 USE_OPLINE
4295 zend_free_op free_op1;
4296 zval *array_ptr, **array_ptr_ptr;
4297 HashTable *fe_ht;
4298 zend_object_iterator *iter = NULL;
4299 zend_class_entry *ce = NULL;
4300 zend_bool is_empty = 0;
4301
4302 SAVE_OPLINE();
4303
4304 if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) &&
4305 (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
4306 array_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
4307 if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
4308 MAKE_STD_ZVAL(array_ptr);
4309 ZVAL_NULL(array_ptr);
4310 } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
4311 if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
4312 zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
4313 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
4314 }
4315
4316 ce = Z_OBJCE_PP(array_ptr_ptr);
4317 if (!ce || ce->get_iterator == NULL) {
4318 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
4319 Z_ADDREF_PP(array_ptr_ptr);
4320 }
4321 array_ptr = *array_ptr_ptr;
4322 } else {
4323 if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
4324 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
4325 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
4326 Z_SET_ISREF_PP(array_ptr_ptr);
4327 }
4328 }
4329 array_ptr = *array_ptr_ptr;
4330 Z_ADDREF_P(array_ptr);
4331 }
4332 } else {
4333 array_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
4334 if (IS_OP1_TMP_FREE()) {
4335 zval *tmp;
4336
4337 ALLOC_ZVAL(tmp);
4338 INIT_PZVAL_COPY(tmp, array_ptr);
4339 array_ptr = tmp;
4340 if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
4341 ce = Z_OBJCE_P(array_ptr);
4342 if (ce && ce->get_iterator) {
4343 Z_DELREF_P(array_ptr);
4344 }
4345 }
4346 } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
4347 ce = Z_OBJCE_P(array_ptr);
4348 if (!ce || !ce->get_iterator) {
4349 if (OP1_TYPE == IS_CV) {
4350 Z_ADDREF_P(array_ptr);
4351 }
4352 }
4353 } else if (OP1_TYPE == IS_CONST ||
4354 (OP1_TYPE == IS_CV &&
4355 !Z_ISREF_P(array_ptr) &&
4356 Z_REFCOUNT_P(array_ptr) > 1) ||
4357 (OP1_TYPE == IS_VAR &&
4358 !Z_ISREF_P(array_ptr) &&
4359 Z_REFCOUNT_P(array_ptr) > 2)) {
4360 zval *tmp;
4361
4362 if (OP1_TYPE == IS_VAR) {
4363 Z_DELREF_P(array_ptr);
4364 }
4365 ALLOC_ZVAL(tmp);
4366 INIT_PZVAL_COPY(tmp, array_ptr);
4367 zval_copy_ctor(tmp);
4368 array_ptr = tmp;
4369 } else if (OP1_TYPE == IS_CV) {
4370 Z_ADDREF_P(array_ptr);
4371 }
4372 }
4373
4374 if (ce && ce->get_iterator) {
4375 iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
4376
4377 if (OP1_TYPE == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
4378 FREE_OP1_IF_VAR();
4379 }
4380 if (iter && EXPECTED(EG(exception) == NULL)) {
4381 array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
4382 } else {
4383 if (OP1_TYPE == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
4384 FREE_OP1_VAR_PTR();
4385 }
4386 if (!EG(exception)) {
4387 zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
4388 }
4389 zend_throw_exception_internal(NULL TSRMLS_CC);
4390 HANDLE_EXCEPTION();
4391 }
4392 }
4393
4394 EX_T(opline->result.var).fe.ptr = array_ptr;
4395
4396 if (iter) {
4397 iter->index = 0;
4398 if (iter->funcs->rewind) {
4399 iter->funcs->rewind(iter TSRMLS_CC);
4400 if (UNEXPECTED(EG(exception) != NULL)) {
4401 zval_ptr_dtor(&array_ptr);
4402 if (OP1_TYPE == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
4403 FREE_OP1_VAR_PTR();
4404 }
4405 HANDLE_EXCEPTION();
4406 }
4407 }
4408 is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
4409 if (UNEXPECTED(EG(exception) != NULL)) {
4410 zval_ptr_dtor(&array_ptr);
4411 if (OP1_TYPE == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
4412 FREE_OP1_VAR_PTR();
4413 }
4414 HANDLE_EXCEPTION();
4415 }
4416 iter->index = -1;
4417 } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
4418 zend_hash_internal_pointer_reset(fe_ht);
4419 if (ce) {
4420 zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
4421 while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
4422 char *str_key;
4423 uint str_key_len;
4424 ulong int_key;
4425 zend_uchar key_type;
4426
4427 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
4428 if (key_type != HASH_KEY_NON_EXISTENT &&
4429 (key_type == HASH_KEY_IS_LONG ||
4430 zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
4431 break;
4432 }
4433 zend_hash_move_forward(fe_ht);
4434 }
4435 }
4436 is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
4437 zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
4438 } else {
4439 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
4440 is_empty = 1;
4441 }
4442
4443 if (OP1_TYPE == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
4444 FREE_OP1_VAR_PTR();
4445 }
4446 if (is_empty) {
4447 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
4448 } else {
4449 CHECK_EXCEPTION();
4450 ZEND_VM_NEXT_OPCODE();
4451 }
4452 }
4453
4454 ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
4455 {
4456 USE_OPLINE
4457 zend_free_op free_op1;
4458 zval *array = EX_T(opline->op1.var).fe.ptr;
4459 zval **value;
4460 HashTable *fe_ht;
4461 zend_object_iterator *iter = NULL;
4462
4463 zval *key = NULL;
4464 if (opline->extended_value & ZEND_FE_FETCH_WITH_KEY) {
4465 key = &EX_T((opline+1)->result.var).tmp_var;
4466 }
4467
4468 SAVE_OPLINE();
4469
4470 switch (zend_iterator_unwrap(array, &iter TSRMLS_CC)) {
4471 default:
4472 case ZEND_ITER_INVALID:
4473 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
4474 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
4475
4476 case ZEND_ITER_PLAIN_OBJECT: {
4477 zend_object *zobj = zend_objects_get_address(array TSRMLS_CC);
4478 int key_type;
4479 char *str_key;
4480 zend_uint str_key_len;
4481 zend_ulong int_key;
4482
4483 fe_ht = Z_OBJPROP_P(array);
4484 zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
4485 do {
4486 if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
4487
4488 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
4489 }
4490 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
4491
4492 zend_hash_move_forward(fe_ht);
4493 } while (key_type != HASH_KEY_IS_LONG &&
4494 zend_check_property_access(zobj, str_key, str_key_len - 1 TSRMLS_CC) != SUCCESS);
4495
4496 if (key) {
4497 if (key_type == HASH_KEY_IS_LONG) {
4498 ZVAL_LONG(key, int_key);
4499 } else {
4500 const char *class_name, *prop_name;
4501 int prop_name_len;
4502 zend_unmangle_property_name_ex(
4503 str_key, str_key_len - 1, &class_name, &prop_name, &prop_name_len
4504 );
4505 ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
4506 }
4507 }
4508
4509 zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
4510 break;
4511 }
4512
4513 case ZEND_ITER_PLAIN_ARRAY:
4514 fe_ht = Z_ARRVAL_P(array);
4515 zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
4516 if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
4517
4518 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
4519 }
4520 if (key) {
4521 zend_hash_get_current_key_zval(fe_ht, key);
4522 }
4523 zend_hash_move_forward(fe_ht);
4524 zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
4525 break;
4526
4527 case ZEND_ITER_OBJECT:
4528
4529 if (iter && ++iter->index > 0) {
4530
4531
4532 iter->funcs->move_forward(iter TSRMLS_CC);
4533 if (UNEXPECTED(EG(exception) != NULL)) {
4534 zval_ptr_dtor(&array);
4535 HANDLE_EXCEPTION();
4536 }
4537 }
4538
4539 if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
4540
4541 if (UNEXPECTED(EG(exception) != NULL)) {
4542 zval_ptr_dtor(&array);
4543 HANDLE_EXCEPTION();
4544 }
4545 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
4546 }
4547 iter->funcs->get_current_data(iter, &value TSRMLS_CC);
4548 if (UNEXPECTED(EG(exception) != NULL)) {
4549 zval_ptr_dtor(&array);
4550 HANDLE_EXCEPTION();
4551 }
4552 if (!value) {
4553
4554 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
4555 }
4556 if (key) {
4557 if (iter->funcs->get_current_key) {
4558 iter->funcs->get_current_key(iter, key TSRMLS_CC);
4559 if (UNEXPECTED(EG(exception) != NULL)) {
4560 zval_ptr_dtor(&array);
4561 HANDLE_EXCEPTION();
4562 }
4563 } else {
4564 ZVAL_LONG(key, iter->index);
4565 }
4566 }
4567 break;
4568 }
4569
4570 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
4571 SEPARATE_ZVAL_IF_NOT_REF(value);
4572 Z_SET_ISREF_PP(value);
4573 EX_T(opline->result.var).var.ptr_ptr = value;
4574 Z_ADDREF_PP(value);
4575 } else {
4576 PZVAL_LOCK(*value);
4577 EX_T(opline->result.var).var.ptr = *value;
4578 }
4579
4580 CHECK_EXCEPTION();
4581 ZEND_VM_INC_OPCODE();
4582 ZEND_VM_NEXT_OPCODE();
4583 }
4584
4585 ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
4586 {
4587 USE_OPLINE
4588 zval **value;
4589 zend_bool isset = 1;
4590
4591 SAVE_OPLINE();
4592 if (OP1_TYPE == IS_CV &&
4593 OP2_TYPE == IS_UNUSED &&
4594 (opline->extended_value & ZEND_QUICK_SET)) {
4595 if (EX_CV(opline->op1.var)) {
4596 value = EX_CV(opline->op1.var);
4597 } else if (EG(active_symbol_table)) {
4598 zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
4599
4600 if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
4601 isset = 0;
4602 }
4603 } else {
4604 isset = 0;
4605 }
4606 } else {
4607 HashTable *target_symbol_table;
4608 zend_free_op free_op1;
4609 zval tmp, *varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
4610
4611 if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
4612 ZVAL_COPY_VALUE(&tmp, varname);
4613 zval_copy_ctor(&tmp);
4614 convert_to_string(&tmp);
4615 varname = &tmp;
4616 }
4617
4618 if (OP2_TYPE != IS_UNUSED) {
4619 zend_class_entry *ce;
4620
4621 if (OP2_TYPE == IS_CONST) {
4622 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
4623 ce = CACHED_PTR(opline->op2.literal->cache_slot);
4624 } else {
4625 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);
4626 if (UNEXPECTED(ce == NULL)) {
4627 CHECK_EXCEPTION();
4628 ZEND_VM_NEXT_OPCODE();
4629 }
4630 CACHE_PTR(opline->op2.literal->cache_slot, ce);
4631 }
4632 } else {
4633 ce = EX_T(opline->op2.var).class_entry;
4634 }
4635 value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
4636 if (!value) {
4637 isset = 0;
4638 }
4639 } else {
4640 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
4641 if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
4642 isset = 0;
4643 }
4644 }
4645
4646 if (OP1_TYPE != IS_CONST && varname == &tmp) {
4647 zval_dtor(&tmp);
4648 }
4649 FREE_OP1();
4650 }
4651
4652 if (opline->extended_value & ZEND_ISSET) {
4653 if (isset && Z_TYPE_PP(value) != IS_NULL) {
4654 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
4655 } else {
4656 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
4657 }
4658 } else {
4659 if (!isset || !i_zend_is_true(*value)) {
4660 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
4661 } else {
4662 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
4663 }
4664 }
4665
4666 CHECK_EXCEPTION();
4667 ZEND_VM_NEXT_OPCODE();
4668 }
4669
4670 ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|TMP|VAR|CV, int prop_dim)
4671 {
4672 USE_OPLINE
4673 zend_free_op free_op1, free_op2;
4674 zval *container;
4675 zval **value = NULL;
4676 int result = 0;
4677 ulong hval;
4678 zval *offset;
4679
4680 SAVE_OPLINE();
4681 container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
4682 offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
4683
4684 if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
4685 HashTable *ht;
4686 int isset = 0;
4687
4688 ht = Z_ARRVAL_P(container);
4689
4690 switch (Z_TYPE_P(offset)) {
4691 case IS_DOUBLE:
4692 hval = zend_dval_to_lval(Z_DVAL_P(offset));
4693 ZEND_VM_C_GOTO(num_index_prop);
4694 case IS_RESOURCE:
4695 case IS_BOOL:
4696 case IS_LONG:
4697 hval = Z_LVAL_P(offset);
4698 ZEND_VM_C_LABEL(num_index_prop):
4699 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
4700 isset = 1;
4701 }
4702 break;
4703 case IS_STRING:
4704 if (OP2_TYPE == IS_CONST) {
4705 hval = Z_HASH_P(offset);
4706 } else {
4707 ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index_prop));
4708 hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
4709 }
4710 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
4711 isset = 1;
4712 }
4713 break;
4714 case IS_NULL:
4715 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
4716 isset = 1;
4717 }
4718 break;
4719 default:
4720 zend_error(E_WARNING, "Illegal offset type in isset or empty");
4721 break;
4722 }
4723
4724 if (opline->extended_value & ZEND_ISSET) {
4725 if (isset && Z_TYPE_PP(value) == IS_NULL) {
4726 result = 0;
4727 } else {
4728 result = isset;
4729 }
4730 } else {
4731 if (!isset || !i_zend_is_true(*value)) {
4732 result = 0;
4733 } else {
4734 result = 1;
4735 }
4736 }
4737 FREE_OP2();
4738 } else if (Z_TYPE_P(container) == IS_OBJECT) {
4739 if (IS_OP2_TMP_FREE()) {
4740 MAKE_REAL_ZVAL_PTR(offset);
4741 }
4742 if (prop_dim) {
4743 if (Z_OBJ_HT_P(container)->has_property) {
4744 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
4745 } else {
4746 zend_error(E_NOTICE, "Trying to check property of non-object");
4747 result = 0;
4748 }
4749 } else {
4750 if (Z_OBJ_HT_P(container)->has_dimension) {
4751 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
4752 } else {
4753 zend_error(E_NOTICE, "Trying to check element of non-array");
4754 result = 0;
4755 }
4756 }
4757 if (IS_OP2_TMP_FREE()) {
4758 zval_ptr_dtor(&offset);
4759 } else {
4760 FREE_OP2();
4761 }
4762 } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) {
4763 zval tmp;
4764
4765 if (Z_TYPE_P(offset) != IS_LONG) {
4766 if (Z_TYPE_P(offset) <= IS_BOOL
4767 || (Z_TYPE_P(offset) == IS_STRING
4768 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
4769 ZVAL_COPY_VALUE(&tmp, offset);
4770 zval_copy_ctor(&tmp);
4771 convert_to_long(&tmp);
4772 offset = &tmp;
4773 } else {
4774
4775 result = 0;
4776 }
4777 }
4778 if (Z_TYPE_P(offset) == IS_LONG) {
4779 if (opline->extended_value & ZEND_ISSET) {
4780 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
4781 result = 1;
4782 }
4783 } else {
4784 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
4785 result = 1;
4786 }
4787 }
4788 }
4789 FREE_OP2();
4790 } else {
4791 FREE_OP2();
4792 }
4793
4794 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
4795 if (opline->extended_value & ZEND_ISSET) {
4796 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
4797 } else {
4798 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
4799 }
4800
4801 FREE_OP1_IF_VAR();
4802
4803 CHECK_EXCEPTION();
4804 ZEND_VM_NEXT_OPCODE();
4805 }
4806
4807 ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
4808 {
4809 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, prop_dim, 0);
4810 }
4811
4812 ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
4813 {
4814 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, prop_dim, 1);
4815 }
4816
4817 ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMP|VAR|UNUSED|CV, ANY)
4818 {
4819 #if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
4820 USE_OPLINE
4821
4822 SAVE_OPLINE();
4823 if (OP1_TYPE != IS_UNUSED) {
4824 zend_free_op free_op1;
4825 zval *ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
4826
4827 if (Z_TYPE_P(ptr) == IS_LONG) {
4828 EG(exit_status) = Z_LVAL_P(ptr);
4829 } else {
4830 zend_print_variable(ptr);
4831 }
4832 FREE_OP1();
4833 }
4834 #endif
4835 zend_bailout();
4836 ZEND_VM_NEXT_OPCODE();
4837 }
4838
4839 ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY)
4840 {
4841 USE_OPLINE
4842
4843 SAVE_OPLINE();
4844 Z_LVAL(EX_T(opline->result.var).tmp_var) = EG(error_reporting);
4845 Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_LONG;
4846 if (EX(old_error_reporting) == NULL) {
4847 EX(old_error_reporting) = &EX_T(opline->result.var).tmp_var;
4848 }
4849
4850 if (EG(error_reporting)) {
4851 do {
4852 EG(error_reporting) = 0;
4853 if (!EG(error_reporting_ini_entry)) {
4854 if (UNEXPECTED(zend_hash_find(EG(ini_directives), "error_reporting", sizeof("error_reporting"), (void **) &EG(error_reporting_ini_entry)) == FAILURE)) {
4855 break;
4856 }
4857 }
4858 if (!EG(error_reporting_ini_entry)->modified) {
4859 if (!EG(modified_ini_directives)) {
4860 ALLOC_HASHTABLE(EG(modified_ini_directives));
4861 zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
4862 }
4863 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)) {
4864 EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
4865 EG(error_reporting_ini_entry)->orig_value_length = EG(error_reporting_ini_entry)->value_length;
4866 EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
4867 EG(error_reporting_ini_entry)->modified = 1;
4868 }
4869 } else if (EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value) {
4870 efree(EG(error_reporting_ini_entry)->value);
4871 }
4872 EG(error_reporting_ini_entry)->value = estrndup("0", sizeof("0")-1);
4873 EG(error_reporting_ini_entry)->value_length = sizeof("0")-1;
4874 } while (0);
4875 }
4876 CHECK_EXCEPTION();
4877 ZEND_VM_NEXT_OPCODE();
4878 }
4879
4880 ZEND_VM_HANDLER(142, ZEND_RAISE_ABSTRACT_ERROR, ANY, ANY)
4881 {
4882 SAVE_OPLINE();
4883 zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name);
4884 ZEND_VM_NEXT_OPCODE();
4885 }
4886
4887 ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY)
4888 {
4889 USE_OPLINE
4890 zval restored_error_reporting;
4891
4892 SAVE_OPLINE();
4893 if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.var).tmp_var) != 0) {
4894 Z_TYPE(restored_error_reporting) = IS_LONG;
4895 Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.var).tmp_var);
4896 EG(error_reporting) = Z_LVAL(restored_error_reporting);
4897 convert_to_string(&restored_error_reporting);
4898 if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) {
4899 if (EXPECTED(EG(error_reporting_ini_entry)->modified &&
4900 EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value)) {
4901 efree(EG(error_reporting_ini_entry)->value);
4902 }
4903 EG(error_reporting_ini_entry)->value = Z_STRVAL(restored_error_reporting);
4904 EG(error_reporting_ini_entry)->value_length = Z_STRLEN(restored_error_reporting);
4905 } else {
4906 zendi_zval_dtor(restored_error_reporting);
4907 }
4908 }
4909 if (EX(old_error_reporting) == &EX_T(opline->op1.var).tmp_var) {
4910 EX(old_error_reporting) = NULL;
4911 }
4912 CHECK_EXCEPTION();
4913 ZEND_VM_NEXT_OPCODE();
4914 }
4915
4916 ZEND_VM_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, ANY)
4917 {
4918 USE_OPLINE
4919 zend_free_op free_op1;
4920 zval *value;
4921
4922 SAVE_OPLINE();
4923 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
4924
4925 if (i_zend_is_true(value)) {
4926 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
4927 if (!IS_OP1_TMP_FREE()) {
4928 zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
4929 }
4930 FREE_OP1_IF_VAR();
4931 #if DEBUG_ZEND>=2
4932 printf("Conditional jmp to %d\n", opline->op2.opline_num);
4933 #endif
4934 ZEND_VM_JMP(opline->op2.jmp_addr);
4935 }
4936
4937 FREE_OP1();
4938 CHECK_EXCEPTION();
4939 ZEND_VM_NEXT_OPCODE();
4940 }
4941
4942 ZEND_VM_HANDLER(158, ZEND_JMP_SET_VAR, CONST|TMP|VAR|CV, ANY)
4943 {
4944 USE_OPLINE
4945 zend_free_op free_op1;
4946 zval *value, *ret;
4947
4948 SAVE_OPLINE();
4949 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
4950
4951 if (i_zend_is_true(value)) {
4952 if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
4953 Z_ADDREF_P(value);
4954 EX_T(opline->result.var).var.ptr = value;
4955 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
4956 } else {
4957 ALLOC_ZVAL(ret);
4958 INIT_PZVAL_COPY(ret, value);
4959 EX_T(opline->result.var).var.ptr = ret;
4960 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
4961 if (!IS_OP1_TMP_FREE()) {
4962 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
4963 }
4964 }
4965 FREE_OP1_IF_VAR();
4966 #if DEBUG_ZEND>=2
4967 printf("Conditional jmp to %d\n", opline->op2.opline_num);
4968 #endif
4969 ZEND_VM_JMP(opline->op2.jmp_addr);
4970 }
4971
4972 FREE_OP1();
4973 CHECK_EXCEPTION();
4974 ZEND_VM_NEXT_OPCODE();
4975 }
4976
4977 ZEND_VM_HANDLER(22, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY)
4978 {
4979 USE_OPLINE
4980 zend_free_op free_op1;
4981 zval *value;
4982
4983 SAVE_OPLINE();
4984 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
4985
4986 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
4987 if (!IS_OP1_TMP_FREE()) {
4988 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
4989 }
4990 FREE_OP1_IF_VAR();
4991 CHECK_EXCEPTION();
4992 ZEND_VM_NEXT_OPCODE();
4993 }
4994
4995 ZEND_VM_HANDLER(157, ZEND_QM_ASSIGN_VAR, CONST|TMP|VAR|CV, ANY)
4996 {
4997 USE_OPLINE
4998 zend_free_op free_op1;
4999 zval *value, *ret;
5000
5001 SAVE_OPLINE();
5002 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
5003
5004 if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
5005 Z_ADDREF_P(value);
5006 EX_T(opline->result.var).var.ptr = value;
5007 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
5008 } else {
5009 ALLOC_ZVAL(ret);
5010 INIT_PZVAL_COPY(ret, value);
5011 EX_T(opline->result.var).var.ptr = ret;
5012 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
5013 if (!IS_OP1_TMP_FREE()) {
5014 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
5015 }
5016 }
5017
5018 FREE_OP1_IF_VAR();
5019 CHECK_EXCEPTION();
5020 ZEND_VM_NEXT_OPCODE();
5021 }
5022
5023 ZEND_VM_HANDLER(101, ZEND_EXT_STMT, ANY, ANY)
5024 {
5025 SAVE_OPLINE();
5026 if (!EG(no_extensions)) {
5027 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, EX(op_array) TSRMLS_CC);
5028 }
5029 CHECK_EXCEPTION();
5030 ZEND_VM_NEXT_OPCODE();
5031 }
5032
5033 ZEND_VM_HANDLER(102, ZEND_EXT_FCALL_BEGIN, ANY, ANY)
5034 {
5035 SAVE_OPLINE();
5036 if (!EG(no_extensions)) {
5037 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, EX(op_array) TSRMLS_CC);
5038 }
5039 CHECK_EXCEPTION();
5040 ZEND_VM_NEXT_OPCODE();
5041 }
5042
5043 ZEND_VM_HANDLER(103, ZEND_EXT_FCALL_END, ANY, ANY)
5044 {
5045 SAVE_OPLINE();
5046 if (!EG(no_extensions)) {
5047 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, EX(op_array) TSRMLS_CC);
5048 }
5049 CHECK_EXCEPTION();
5050 ZEND_VM_NEXT_OPCODE();
5051 }
5052
5053 ZEND_VM_HANDLER(139, ZEND_DECLARE_CLASS, ANY, ANY)
5054 {
5055 USE_OPLINE
5056
5057 SAVE_OPLINE();
5058 EX_T(opline->result.var).class_entry = do_bind_class(EX(op_array), opline, EG(class_table), 0 TSRMLS_CC);
5059 CHECK_EXCEPTION();
5060 ZEND_VM_NEXT_OPCODE();
5061 }
5062
5063 ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, ANY)
5064 {
5065 USE_OPLINE
5066
5067 SAVE_OPLINE();
5068 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);
5069 CHECK_EXCEPTION();
5070 ZEND_VM_NEXT_OPCODE();
5071 }
5072
5073 ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, ANY, ANY)
5074 {
5075 USE_OPLINE
5076 zend_class_entry **pce, **pce_orig;
5077
5078 SAVE_OPLINE();
5079 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 ||
5080 (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 &&
5081 *pce != *pce_orig)) {
5082 do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
5083 }
5084 CHECK_EXCEPTION();
5085 ZEND_VM_NEXT_OPCODE();
5086 }
5087
5088 ZEND_VM_HANDLER(141, ZEND_DECLARE_FUNCTION, ANY, ANY)
5089 {
5090 USE_OPLINE
5091
5092 SAVE_OPLINE();
5093 do_bind_function(EX(op_array), opline, EG(function_table), 0);
5094 CHECK_EXCEPTION();
5095 ZEND_VM_NEXT_OPCODE();
5096 }
5097
5098 ZEND_VM_HANDLER(105, ZEND_TICKS, ANY, ANY)
5099 {
5100 USE_OPLINE
5101
5102 SAVE_OPLINE();
5103 if (++EG(ticks_count)>=opline->extended_value) {
5104 EG(ticks_count)=0;
5105 if (zend_ticks_function) {
5106 zend_ticks_function(opline->extended_value);
5107 }
5108 }
5109 CHECK_EXCEPTION();
5110 ZEND_VM_NEXT_OPCODE();
5111 }
5112
5113 ZEND_VM_HANDLER(138, ZEND_INSTANCEOF, TMP|VAR|CV, ANY)
5114 {
5115 USE_OPLINE
5116 zend_free_op free_op1;
5117 zval *expr;
5118 zend_bool result;
5119
5120 SAVE_OPLINE();
5121 expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
5122
5123 if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
5124 result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
5125 } else {
5126 result = 0;
5127 }
5128 ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
5129 FREE_OP1();
5130 CHECK_EXCEPTION();
5131 ZEND_VM_NEXT_OPCODE();
5132 }
5133
5134 ZEND_VM_HANDLER(104, ZEND_EXT_NOP, ANY, ANY)
5135 {
5136 ZEND_VM_NEXT_OPCODE();
5137 }
5138
5139 ZEND_VM_HANDLER(0, ZEND_NOP, ANY, ANY)
5140 {
5141 ZEND_VM_NEXT_OPCODE();
5142 }
5143
5144 ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST)
5145 {
5146 USE_OPLINE
5147 zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
5148 zend_class_entry *iface;
5149
5150 SAVE_OPLINE();
5151 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
5152 iface = CACHED_PTR(opline->op2.literal->cache_slot);
5153 } else {
5154 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);
5155 if (UNEXPECTED(iface == NULL)) {
5156 CHECK_EXCEPTION();
5157 ZEND_VM_NEXT_OPCODE();
5158 }
5159 CACHE_PTR(opline->op2.literal->cache_slot, iface);
5160 }
5161
5162 if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
5163 zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
5164 }
5165 zend_do_implement_interface(ce, iface TSRMLS_CC);
5166
5167 CHECK_EXCEPTION();
5168 ZEND_VM_NEXT_OPCODE();
5169 }
5170
5171 ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY)
5172 {
5173 USE_OPLINE
5174 zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
5175 zend_class_entry *trait;
5176
5177 SAVE_OPLINE();
5178 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
5179 trait = CACHED_PTR(opline->op2.literal->cache_slot);
5180 } else {
5181 trait = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv),
5182 Z_STRLEN_P(opline->op2.zv),
5183 opline->op2.literal + 1,
5184 opline->extended_value TSRMLS_CC);
5185 if (UNEXPECTED(trait == NULL)) {
5186 CHECK_EXCEPTION();
5187 ZEND_VM_NEXT_OPCODE();
5188 }
5189 if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) {
5190 zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name, trait->name);
5191 }
5192 CACHE_PTR(opline->op2.literal->cache_slot, trait);
5193 }
5194
5195 zend_do_implement_trait(ce, trait TSRMLS_CC);
5196
5197 CHECK_EXCEPTION();
5198 ZEND_VM_NEXT_OPCODE();
5199 }
5200
5201 ZEND_VM_HANDLER(155, ZEND_BIND_TRAITS, ANY, ANY)
5202 {
5203 USE_OPLINE
5204 zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
5205
5206 SAVE_OPLINE();
5207 zend_do_bind_traits(ce TSRMLS_CC);
5208 CHECK_EXCEPTION();
5209 ZEND_VM_NEXT_OPCODE();
5210 }
5211
5212 ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
5213 {
5214 zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes;
5215 int i;
5216 zend_uint catch_op_num = 0, finally_op_num = 0, finally_op_end = 0;
5217 void **stack_frame;
5218
5219
5220
5221 stack_frame = zend_vm_stack_frame_base(execute_data);
5222
5223
5224
5225 while (zend_vm_stack_top(TSRMLS_C) != stack_frame) {
5226 zval *stack_zval_p = zend_vm_stack_pop(TSRMLS_C);
5227 zval_ptr_dtor(&stack_zval_p);
5228 }
5229
5230 for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
5231 if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
5232
5233 break;
5234 }
5235 if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
5236 catch_op_num = EX(op_array)->try_catch_array[i].catch_op;
5237 }
5238 if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
5239 finally_op_num = EX(op_array)->try_catch_array[i].finally_op;
5240 }
5241 if (op_num >= EG(active_op_array)->try_catch_array[i].finally_op &&
5242 op_num < EG(active_op_array)->try_catch_array[i].finally_end) {
5243 finally_op_end = EG(active_op_array)->try_catch_array[i].finally_end;
5244 }
5245 }
5246
5247 if (EX(call) >= EX(call_slots)) {
5248 call_slot *call = EX(call);
5249 do {
5250 if (call->object) {
5251 if (call->is_ctor_call) {
5252 if (call->is_ctor_result_used) {
5253 Z_DELREF_P(call->object);
5254 }
5255 if (Z_REFCOUNT_P(call->object) == 1) {
5256 zend_object_store_ctor_failed(call->object TSRMLS_CC);
5257 }
5258 }
5259 zval_ptr_dtor(&call->object);
5260 }
5261 if (call->fbc->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) {
5262 efree((char *) call->fbc->common.function_name);
5263 efree(call->fbc);
5264 }
5265 call--;
5266 } while (call >= EX(call_slots));
5267 EX(call) = NULL;
5268 }
5269
5270 for (i=0; i<EX(op_array)->last_brk_cont; i++) {
5271 if (EX(op_array)->brk_cont_array[i].start < 0) {
5272 continue;
5273 } else if (EX(op_array)->brk_cont_array[i].start > op_num) {
5274
5275 break;
5276 } else if (op_num < EX(op_array)->brk_cont_array[i].brk) {
5277 if (!catch_op_num ||
5278 catch_op_num >= EX(op_array)->brk_cont_array[i].brk) {
5279 zend_op *brk_opline = &EX(op_array)->opcodes[EX(op_array)->brk_cont_array[i].brk];
5280
5281 switch (brk_opline->opcode) {
5282 case ZEND_SWITCH_FREE:
5283 if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
5284 zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
5285 }
5286 break;
5287 case ZEND_FREE:
5288 if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
5289 zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
5290 }
5291 break;
5292 }
5293 }
5294 }
5295 }
5296
5297
5298 if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) {
5299 zval restored_error_reporting;
5300
5301 Z_TYPE(restored_error_reporting) = IS_LONG;
5302 Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting));
5303 convert_to_string(&restored_error_reporting);
5304 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);
5305 zendi_zval_dtor(restored_error_reporting);
5306 }
5307 EX(old_error_reporting) = NULL;
5308
5309 if (finally_op_num && (!catch_op_num || catch_op_num >= finally_op_num)) {
5310 if (EX(delayed_exception)) {
5311 zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
5312 }
5313 EX(delayed_exception) = EG(exception);
5314 EG(exception) = NULL;
5315 EX(fast_ret) = NULL;
5316 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
5317 ZEND_VM_CONTINUE();
5318 } else if (catch_op_num) {
5319 if (finally_op_end && catch_op_num > finally_op_end) {
5320
5321 if (EX(delayed_exception)) {
5322 zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
5323 EX(delayed_exception) = NULL;
5324 }
5325 }
5326 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
5327 ZEND_VM_CONTINUE();
5328 } else {
5329 if (EX(delayed_exception)) {
5330 zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
5331 EX(delayed_exception) = NULL;
5332 }
5333 if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
5334 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_GENERATOR_RETURN);
5335 } else {
5336 ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
5337 }
5338 }
5339 }
5340
5341 ZEND_VM_HANDLER(146, ZEND_VERIFY_ABSTRACT_CLASS, ANY, ANY)
5342 {
5343 USE_OPLINE
5344
5345 SAVE_OPLINE();
5346 zend_verify_abstract_class(EX_T(opline->op1.var).class_entry TSRMLS_CC);
5347 CHECK_EXCEPTION();
5348 ZEND_VM_NEXT_OPCODE();
5349 }
5350
5351 ZEND_VM_HANDLER(150, ZEND_USER_OPCODE, ANY, ANY)
5352 {
5353 USE_OPLINE
5354 int ret;
5355
5356 SAVE_OPLINE();
5357 ret = zend_user_opcode_handlers[opline->opcode](ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL);
5358 LOAD_OPLINE();
5359
5360 switch (ret) {
5361 case ZEND_USER_OPCODE_CONTINUE:
5362 ZEND_VM_CONTINUE();
5363 case ZEND_USER_OPCODE_RETURN:
5364 if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
5365 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_GENERATOR_RETURN);
5366 } else {
5367 ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
5368 }
5369 case ZEND_USER_OPCODE_ENTER:
5370 ZEND_VM_ENTER();
5371 case ZEND_USER_OPCODE_LEAVE:
5372 ZEND_VM_LEAVE();
5373 case ZEND_USER_OPCODE_DISPATCH:
5374 ZEND_VM_DISPATCH(opline->opcode, opline);
5375 default:
5376 ZEND_VM_DISPATCH((zend_uchar)(ret & 0xff), opline);
5377 }
5378 }
5379
5380 ZEND_VM_HANDLER(143, ZEND_DECLARE_CONST, CONST, CONST)
5381 {
5382 USE_OPLINE
5383 zend_free_op free_op1, free_op2;
5384 zval *name;
5385 zval *val;
5386 zend_constant c;
5387
5388 SAVE_OPLINE();
5389 name = GET_OP1_ZVAL_PTR(BP_VAR_R);
5390 val = GET_OP2_ZVAL_PTR(BP_VAR_R);
5391
5392 if (IS_CONSTANT_TYPE(Z_TYPE_P(val))) {
5393 zval tmp;
5394 zval *tmp_ptr = &tmp;
5395
5396 ZVAL_COPY_VALUE(&tmp, val);
5397 INIT_PZVAL(&tmp);
5398 zval_update_constant(&tmp_ptr, 0 TSRMLS_CC);
5399 c.value = *tmp_ptr;
5400 } else {
5401 INIT_PZVAL_COPY(&c.value, val);
5402 if (Z_TYPE(c.value) == IS_ARRAY) {
5403 HashTable *ht;
5404
5405 ALLOC_HASHTABLE(ht);
5406 zend_hash_init(ht, zend_hash_num_elements(Z_ARRVAL(c.value)), NULL, ZVAL_PTR_DTOR, 0);
5407 zend_hash_copy(ht, Z_ARRVAL(c.value), (copy_ctor_func_t) zval_deep_copy, NULL, sizeof(zval *));
5408 Z_ARRVAL(c.value) = ht;
5409 } else {
5410 zval_copy_ctor(&c.value);
5411 }
5412 }
5413 c.flags = CONST_CS;
5414 c.name = str_strndup(Z_STRVAL_P(name), Z_STRLEN_P(name));
5415 c.name_len = Z_STRLEN_P(name)+1;
5416 c.module_number = PHP_USER_CONSTANT;
5417
5418 if (zend_register_constant(&c TSRMLS_CC) == FAILURE) {
5419 }
5420
5421 FREE_OP1();
5422 FREE_OP2();
5423 CHECK_EXCEPTION();
5424 ZEND_VM_NEXT_OPCODE();
5425 }
5426
5427 ZEND_VM_HANDLER(153, ZEND_DECLARE_LAMBDA_FUNCTION, CONST, UNUSED)
5428 {
5429 USE_OPLINE
5430 zend_function *op_array;
5431
5432 SAVE_OPLINE();
5433
5434 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) ||
5435 UNEXPECTED(op_array->type != ZEND_USER_FUNCTION)) {
5436 zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
5437 }
5438
5439 if (UNEXPECTED((op_array->common.fn_flags & ZEND_ACC_STATIC) ||
5440 (EX(prev_execute_data) &&
5441 EX(prev_execute_data)->function_state.function->common.fn_flags & ZEND_ACC_STATIC))) {
5442 zend_create_closure(&EX_T(opline->result.var).tmp_var, (zend_function *) op_array, EG(called_scope), NULL TSRMLS_CC);
5443 } else {
5444 zend_create_closure(&EX_T(opline->result.var).tmp_var, (zend_function *) op_array, EG(scope), EG(This) TSRMLS_CC);
5445 }
5446
5447 CHECK_EXCEPTION();
5448 ZEND_VM_NEXT_OPCODE();
5449 }
5450
5451 ZEND_VM_HANDLER(156, ZEND_SEPARATE, VAR, UNUSED)
5452 {
5453 USE_OPLINE
5454 zval *var_ptr, *new_zv;
5455
5456 SAVE_OPLINE();
5457 var_ptr = EX_T(opline->op1.var).var.ptr;
5458 if (Z_TYPE_P(var_ptr) != IS_OBJECT &&
5459 !PZVAL_IS_REF(var_ptr) &&
5460 Z_REFCOUNT_P(var_ptr) > 1) {
5461
5462 Z_DELREF_P(var_ptr);
5463 ALLOC_ZVAL(new_zv);
5464 INIT_PZVAL_COPY(new_zv, var_ptr);
5465 var_ptr = new_zv;
5466 zval_copy_ctor(var_ptr);
5467 EX_T(opline->op1.var).var.ptr = var_ptr;
5468 }
5469 ZEND_VM_NEXT_OPCODE();
5470 }
5471
5472 ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSED)
5473 {
5474 USE_OPLINE
5475
5476
5477 zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
5478
5479 if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
5480 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
5481 }
5482
5483
5484 if (generator->value) {
5485 zval_ptr_dtor(&generator->value);
5486 }
5487
5488
5489 if (generator->key) {
5490 zval_ptr_dtor(&generator->key);
5491 }
5492
5493
5494 if (OP1_TYPE != IS_UNUSED) {
5495 zend_free_op free_op1;
5496
5497 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
5498
5499
5500 if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
5501 zval *value, *copy;
5502
5503 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
5504
5505 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
5506 ALLOC_ZVAL(copy);
5507 INIT_PZVAL_COPY(copy, value);
5508
5509
5510 if (!IS_OP1_TMP_FREE()) {
5511 zval_copy_ctor(copy);
5512 }
5513
5514 generator->value = copy;
5515 } else {
5516 zval **value_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
5517
5518 if (OP1_TYPE == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
5519 zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
5520 }
5521
5522
5523
5524 if (OP1_TYPE == IS_VAR && !Z_ISREF_PP(value_ptr)
5525 && !(opline->extended_value == ZEND_RETURNS_FUNCTION
5526 && EX_T(opline->op1.var).var.fcall_returned_reference)
5527 && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
5528 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
5529
5530 Z_ADDREF_PP(value_ptr);
5531 generator->value = *value_ptr;
5532 } else {
5533 SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
5534 Z_ADDREF_PP(value_ptr);
5535 generator->value = *value_ptr;
5536 }
5537
5538 FREE_OP1_VAR_PTR();
5539 }
5540 } else {
5541 zval *value = GET_OP1_ZVAL_PTR(BP_VAR_R);
5542
5543
5544 if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR
5545 || PZVAL_IS_REF(value)
5546 ) {
5547 zval *copy;
5548
5549 ALLOC_ZVAL(copy);
5550 INIT_PZVAL_COPY(copy, value);
5551
5552
5553 if (!IS_OP1_TMP_FREE()) {
5554 zval_copy_ctor(copy);
5555 }
5556
5557 generator->value = copy;
5558 FREE_OP1_IF_VAR();
5559 } else {
5560 if (OP1_TYPE == IS_CV) {
5561 Z_ADDREF_P(value);
5562 }
5563 generator->value = value;
5564 }
5565 }
5566 } else {
5567
5568 Z_ADDREF(EG(uninitialized_zval));
5569 generator->value = &EG(uninitialized_zval);
5570 }
5571
5572
5573 if (OP2_TYPE != IS_UNUSED) {
5574 zend_free_op free_op2;
5575 zval *key = GET_OP2_ZVAL_PTR(BP_VAR_R);
5576
5577
5578 if (OP2_TYPE == IS_CONST || OP2_TYPE == IS_TMP_VAR
5579 || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
5580 ) {
5581 zval *copy;
5582
5583 ALLOC_ZVAL(copy);
5584 INIT_PZVAL_COPY(copy, key);
5585
5586
5587 if (!IS_OP2_TMP_FREE()) {
5588 zval_copy_ctor(copy);
5589 }
5590
5591 generator->key = copy;
5592 } else {
5593 Z_ADDREF_P(key);
5594 generator->key = key;
5595 }
5596
5597 if (Z_TYPE_P(generator->key) == IS_LONG
5598 && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
5599 ) {
5600 generator->largest_used_integer_key = Z_LVAL_P(generator->key);
5601 }
5602
5603 FREE_OP2_IF_VAR();
5604 } else {
5605
5606 generator->largest_used_integer_key++;
5607
5608 ALLOC_INIT_ZVAL(generator->key);
5609 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
5610 }
5611
5612 if (RETURN_VALUE_USED(opline)) {
5613
5614
5615 generator->send_target = &EX_T(opline->result.var).var.ptr;
5616 Z_ADDREF(EG(uninitialized_zval));
5617 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
5618 } else {
5619 generator->send_target = NULL;
5620 }
5621
5622
5623
5624 ZEND_VM_INC_OPCODE();
5625
5626
5627
5628 SAVE_OPLINE();
5629
5630 ZEND_VM_RETURN();
5631 }
5632
5633 ZEND_VM_HANDLER(159, ZEND_DISCARD_EXCEPTION, ANY, ANY)
5634 {
5635 if (EX(delayed_exception) != NULL) {
5636
5637 zval_ptr_dtor(&EX(delayed_exception));
5638 EX(delayed_exception) = NULL;
5639 }
5640
5641 ZEND_VM_NEXT_OPCODE();
5642 }
5643
5644 ZEND_VM_HANDLER(162, ZEND_FAST_CALL, ANY, ANY)
5645 {
5646 USE_OPLINE
5647
5648 if ((opline->extended_value & ZEND_FAST_CALL_FROM_CATCH) &&
5649 UNEXPECTED(EG(prev_exception) != NULL)) {
5650
5651 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
5652 ZEND_VM_CONTINUE();
5653 }
5654 if (UNEXPECTED(EX(delayed_exception) != NULL)) {
5655 EX(fast_ret) = NULL;
5656 } else {
5657 EX(fast_ret) = opline;
5658 }
5659 ZEND_VM_SET_OPCODE(opline->op1.jmp_addr);
5660 ZEND_VM_CONTINUE();
5661 }
5662
5663 ZEND_VM_HANDLER(163, ZEND_FAST_RET, ANY, ANY)
5664 {
5665 if (EX(fast_ret)) {
5666 ZEND_VM_SET_OPCODE(EX(fast_ret) + 1);
5667 if ((EX(fast_ret)->extended_value & ZEND_FAST_CALL_FROM_FINALLY)) {
5668 EX(fast_ret) = &EX(op_array)->opcodes[EX(fast_ret)->op2.opline_num];
5669 }
5670 ZEND_VM_CONTINUE();
5671 } else {
5672
5673 USE_OPLINE
5674
5675 if (opline->extended_value == ZEND_FAST_RET_TO_FINALLY) {
5676 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
5677 ZEND_VM_CONTINUE();
5678 } else {
5679 EG(exception) = EX(delayed_exception);
5680 EX(delayed_exception) = NULL;
5681 if (opline->extended_value == ZEND_FAST_RET_TO_CATCH) {
5682 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
5683 ZEND_VM_CONTINUE();
5684 } else if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
5685 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_GENERATOR_RETURN);
5686 } else {
5687 ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
5688 }
5689 }
5690 }
5691 }
5692
5693 ZEND_VM_HANDLER(166, ZEND_POW, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
5694 {
5695 USE_OPLINE
5696 zend_free_op free_op1, free_op2;
5697
5698 SAVE_OPLINE();
5699 pow_function(&EX_T(opline->result.var).tmp_var,
5700 GET_OP1_ZVAL_PTR(BP_VAR_R),
5701 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
5702 FREE_OP1();
5703 FREE_OP2();
5704 CHECK_EXCEPTION();
5705 ZEND_VM_NEXT_OPCODE();
5706 }
5707
5708 ZEND_VM_HANDLER(167, ZEND_ASSIGN_POW, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
5709 {
5710 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op,pow_function);
5711 }
5712
5713 ZEND_VM_EXPORT_HELPER(zend_do_fcall, zend_do_fcall_common_helper)