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_HANDLER
- ZEND_VM_HANDLER
- ZEND_VM_HELPER_EX
- 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_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_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_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_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
- 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
- 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|TMPVAR|CV, CONST|TMPVAR|CV)
29 {
30 USE_OPLINE
31 zend_free_op free_op1, free_op2;
32 zval *op1, *op2, *result;
33
34 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
35 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
36 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
37 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
38 result = EX_VAR(opline->result.var);
39 fast_long_add_function(result, op1, op2);
40 ZEND_VM_NEXT_OPCODE();
41 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
42 result = EX_VAR(opline->result.var);
43 ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));
44 ZEND_VM_NEXT_OPCODE();
45 }
46 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
47 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
48 result = EX_VAR(opline->result.var);
49 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
50 ZEND_VM_NEXT_OPCODE();
51 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
52 result = EX_VAR(opline->result.var);
53 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));
54 ZEND_VM_NEXT_OPCODE();
55 }
56 }
57
58 SAVE_OPLINE();
59 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
60 op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
61 }
62 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
63 op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
64 }
65 add_function(EX_VAR(opline->result.var), op1, op2);
66 FREE_OP1();
67 FREE_OP2();
68 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
69 }
70
71 ZEND_VM_HANDLER(2, ZEND_SUB, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
72 {
73 USE_OPLINE
74 zend_free_op free_op1, free_op2;
75 zval *op1, *op2, *result;
76
77 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
78 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
79 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
80 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
81 result = EX_VAR(opline->result.var);
82 fast_long_sub_function(result, op1, op2);
83 ZEND_VM_NEXT_OPCODE();
84 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
85 result = EX_VAR(opline->result.var);
86 ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2));
87 ZEND_VM_NEXT_OPCODE();
88 }
89 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
90 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
91 result = EX_VAR(opline->result.var);
92 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
93 ZEND_VM_NEXT_OPCODE();
94 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
95 result = EX_VAR(opline->result.var);
96 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2)));
97 ZEND_VM_NEXT_OPCODE();
98 }
99 }
100
101 SAVE_OPLINE();
102 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
103 op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
104 }
105 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
106 op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
107 }
108 sub_function(EX_VAR(opline->result.var), op1, op2);
109 FREE_OP1();
110 FREE_OP2();
111 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
112 }
113
114 ZEND_VM_HANDLER(3, ZEND_MUL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
115 {
116 USE_OPLINE
117 zend_free_op free_op1, free_op2;
118 zval *op1, *op2, *result;
119
120 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
121 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
122 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
123 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
124 zend_long overflow;
125
126 result = EX_VAR(opline->result.var);
127 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
128 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
129 ZEND_VM_NEXT_OPCODE();
130 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
131 result = EX_VAR(opline->result.var);
132 ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2));
133 ZEND_VM_NEXT_OPCODE();
134 }
135 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
136 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
137 result = EX_VAR(opline->result.var);
138 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
139 ZEND_VM_NEXT_OPCODE();
140 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
141 result = EX_VAR(opline->result.var);
142 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2)));
143 ZEND_VM_NEXT_OPCODE();
144 }
145 }
146
147 SAVE_OPLINE();
148 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
149 op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
150 }
151 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
152 op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
153 }
154 mul_function(EX_VAR(opline->result.var), op1, op2);
155 FREE_OP1();
156 FREE_OP2();
157 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
158 }
159
160 ZEND_VM_HANDLER(4, ZEND_DIV, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
161 {
162 USE_OPLINE
163 zend_free_op free_op1, free_op2;
164 zval *op1, *op2;
165
166 SAVE_OPLINE();
167 op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
168 op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
169 fast_div_function(EX_VAR(opline->result.var), op1, op2);
170 FREE_OP1();
171 FREE_OP2();
172 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
173 }
174
175 ZEND_VM_HANDLER(5, ZEND_MOD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
176 {
177 USE_OPLINE
178 zend_free_op free_op1, free_op2;
179 zval *op1, *op2, *result;
180
181 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
182 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
183 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
184 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
185 result = EX_VAR(opline->result.var);
186 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
187 SAVE_OPLINE();
188 zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero");
189 HANDLE_EXCEPTION();
190 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
191
192 ZVAL_LONG(result, 0);
193 } else {
194 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
195 }
196 ZEND_VM_NEXT_OPCODE();
197 }
198 }
199
200 SAVE_OPLINE();
201 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
202 op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
203 }
204 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
205 op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
206 }
207 mod_function(EX_VAR(opline->result.var), op1, op2);
208 FREE_OP1();
209 FREE_OP2();
210 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
211 }
212
213 ZEND_VM_HANDLER(6, ZEND_SL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
214 {
215 USE_OPLINE
216 zend_free_op free_op1, free_op2;
217 zval *op1, *op2;
218
219 SAVE_OPLINE();
220 op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
221 op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
222 shift_left_function(EX_VAR(opline->result.var), op1, op2);
223 FREE_OP1();
224 FREE_OP2();
225 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
226 }
227
228 ZEND_VM_HANDLER(7, ZEND_SR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
229 {
230 USE_OPLINE
231 zend_free_op free_op1, free_op2;
232 zval *op1, *op2;
233
234 SAVE_OPLINE();
235 op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
236 op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
237 shift_right_function(EX_VAR(opline->result.var), op1, op2);
238 FREE_OP1();
239 FREE_OP2();
240 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
241 }
242
243 ZEND_VM_HANDLER(166, ZEND_POW, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
244 {
245 USE_OPLINE
246 zend_free_op free_op1, free_op2;
247 zval *op1, *op2;
248
249 SAVE_OPLINE();
250 op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
251 op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
252 pow_function(EX_VAR(opline->result.var), op1, op2);
253 FREE_OP1();
254 FREE_OP2();
255 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
256 }
257
258 ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
259 {
260 USE_OPLINE
261 zend_free_op free_op1, free_op2;
262 zval *op1, *op2;
263
264 SAVE_OPLINE();
265 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
266 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
267
268 do {
269 if ((OP1_TYPE == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
270 (OP2_TYPE == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
271 zend_string *op1_str = Z_STR_P(op1);
272 zend_string *op2_str = Z_STR_P(op2);
273 zend_string *str;
274
275 if (OP1_TYPE != IS_CONST) {
276 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
277 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
278 FREE_OP1();
279 break;
280 }
281 }
282 if (OP2_TYPE != IS_CONST) {
283 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
284 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
285 FREE_OP1();
286 break;
287 }
288 }
289 if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
290 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
291 size_t len = ZSTR_LEN(op1_str);
292
293 str = zend_string_realloc(op1_str, len + ZSTR_LEN(op2_str), 0);
294 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
295 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
296 break;
297 } else {
298 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
299 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
300 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
301 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
302 }
303 } else {
304 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
305 op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
306 }
307 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
308 op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
309 }
310 concat_function(EX_VAR(opline->result.var), op1, op2);
311 }
312 FREE_OP1();
313 } while (0);
314 FREE_OP2();
315 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
316 }
317
318 ZEND_VM_HANDLER(15, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
319 {
320 USE_OPLINE
321 zend_free_op free_op1, free_op2;
322 zval *op1, *op2;
323 int result;
324
325 SAVE_OPLINE();
326 op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
327 op2 = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
328 result = fast_is_identical_function(op1, op2);
329 FREE_OP1();
330 FREE_OP2();
331 ZEND_VM_SMART_BRANCH(result, 1);
332 ZVAL_BOOL(EX_VAR(opline->result.var), result);
333 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
334 }
335
336 ZEND_VM_HANDLER(16, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
337 {
338 USE_OPLINE
339 zend_free_op free_op1, free_op2;
340 zval *op1, *op2;
341 int result;
342
343 SAVE_OPLINE();
344 op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
345 op2 = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
346 result = fast_is_not_identical_function(op1, op2);
347 FREE_OP1();
348 FREE_OP2();
349 ZEND_VM_SMART_BRANCH(result, 1);
350 ZVAL_BOOL(EX_VAR(opline->result.var), result);
351 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
352 }
353
354 ZEND_VM_HANDLER(17, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
355 {
356 USE_OPLINE
357 zend_free_op free_op1, free_op2;
358 zval *op1, *op2, *result;
359
360 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
361 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
362 do {
363 int result;
364
365 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
366 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
367 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
368 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
369 result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
370 } else {
371 break;
372 }
373 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
374 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
375 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
376 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
377 result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
378 } else {
379 break;
380 }
381 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
382 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
383 if (Z_STR_P(op1) == Z_STR_P(op2)) {
384 result = 1;
385 } else if (Z_STRVAL_P(op1)[0] > '9' || Z_STRVAL_P(op2)[0] > '9') {
386 if (Z_STRLEN_P(op1) != Z_STRLEN_P(op2)) {
387 result = 0;
388 } else {
389 result = (memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) == 0);
390 }
391 } else {
392 result = (zendi_smart_strcmp(Z_STR_P(op1), Z_STR_P(op2)) == 0);
393 }
394 FREE_OP1();
395 FREE_OP2();
396 } else {
397 break;
398 }
399 } else {
400 break;
401 }
402 ZEND_VM_SMART_BRANCH(result, 0);
403 ZVAL_BOOL(EX_VAR(opline->result.var), result);
404 ZEND_VM_NEXT_OPCODE();
405 } while (0);
406
407 SAVE_OPLINE();
408 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
409 op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
410 }
411 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
412 op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
413 }
414 result = EX_VAR(opline->result.var);
415 compare_function(result, op1, op2);
416 ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
417 FREE_OP1();
418 FREE_OP2();
419 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
420 }
421
422 ZEND_VM_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
423 {
424 USE_OPLINE
425 zend_free_op free_op1, free_op2;
426 zval *op1, *op2, *result;
427
428 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
429 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
430 do {
431 int result;
432
433 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
434 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
435 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
436 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
437 result = ((double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
438 } else {
439 break;
440 }
441 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
442 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
443 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
444 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
445 result = (Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
446 } else {
447 break;
448 }
449 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
450 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
451 if (Z_STR_P(op1) == Z_STR_P(op2)) {
452 result = 0;
453 } else if (Z_STRVAL_P(op1)[0] > '9' || Z_STRVAL_P(op2)[0] > '9') {
454 if (Z_STRLEN_P(op1) != Z_STRLEN_P(op2)) {
455 result = 1;
456 } else {
457 result = (memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) != 0);
458 }
459 } else {
460 result = (zendi_smart_strcmp(Z_STR_P(op1), Z_STR_P(op2)) != 0);
461 }
462 FREE_OP1();
463 FREE_OP2();
464 } else {
465 break;
466 }
467 } else {
468 break;
469 }
470 ZEND_VM_SMART_BRANCH(result, 0);
471 ZVAL_BOOL(EX_VAR(opline->result.var), result);
472 ZEND_VM_NEXT_OPCODE();
473 } while (0);
474
475 SAVE_OPLINE();
476 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
477 op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
478 }
479 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
480 op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
481 }
482 result = EX_VAR(opline->result.var);
483 compare_function(result, op1, op2);
484 ZVAL_BOOL(result, Z_LVAL_P(result) != 0);
485 FREE_OP1();
486 FREE_OP2();
487 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
488 }
489
490 ZEND_VM_HANDLER(19, ZEND_IS_SMALLER, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
491 {
492 USE_OPLINE
493 zend_free_op free_op1, free_op2;
494 zval *op1, *op2, *result;
495
496 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
497 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
498 do {
499 int result;
500
501 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
502 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
503 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
504 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
505 result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
506 } else {
507 break;
508 }
509 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
510 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
511 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
512 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
513 result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
514 } else {
515 break;
516 }
517 } else {
518 break;
519 }
520 ZEND_VM_SMART_BRANCH(result, 0);
521 ZVAL_BOOL(EX_VAR(opline->result.var), result);
522 ZEND_VM_NEXT_OPCODE();
523 } while (0);
524
525 SAVE_OPLINE();
526 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
527 op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
528 }
529 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
530 op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
531 }
532 result = EX_VAR(opline->result.var);
533 compare_function(result, op1, op2);
534 ZVAL_BOOL(result, Z_LVAL_P(result) < 0);
535 FREE_OP1();
536 FREE_OP2();
537 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
538 }
539
540 ZEND_VM_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
541 {
542 USE_OPLINE
543 zend_free_op free_op1, free_op2;
544 zval *op1, *op2, *result;
545
546 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
547 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
548 do {
549 int result;
550
551 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
552 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
553 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
554 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
555 result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
556 } else {
557 break;
558 }
559 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
560 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
561 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
562 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
563 result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
564 } else {
565 break;
566 }
567 } else {
568 break;
569 }
570 ZEND_VM_SMART_BRANCH(result, 0);
571 ZVAL_BOOL(EX_VAR(opline->result.var), result);
572 ZEND_VM_NEXT_OPCODE();
573 } while (0);
574
575 SAVE_OPLINE();
576 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
577 op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
578 }
579 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
580 op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
581 }
582 result = EX_VAR(opline->result.var);
583 compare_function(result, op1, op2);
584 ZVAL_BOOL(result, Z_LVAL_P(result) <= 0);
585 FREE_OP1();
586 FREE_OP2();
587 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
588 }
589
590 ZEND_VM_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
591 {
592 USE_OPLINE
593 zend_free_op free_op1, free_op2;
594 zval *op1, *op2;
595
596 SAVE_OPLINE();
597 op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
598 op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
599 compare_function(EX_VAR(opline->result.var), op1, op2);
600 FREE_OP1();
601 FREE_OP2();
602 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
603 }
604
605 ZEND_VM_HANDLER(9, ZEND_BW_OR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
606 {
607 USE_OPLINE
608 zend_free_op free_op1, free_op2;
609 zval *op1, *op2;
610
611 SAVE_OPLINE();
612 op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
613 op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
614 bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
615 FREE_OP1();
616 FREE_OP2();
617 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
618 }
619
620 ZEND_VM_HANDLER(10, ZEND_BW_AND, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
621 {
622 USE_OPLINE
623 zend_free_op free_op1, free_op2;
624 zval *op1, *op2;
625
626 SAVE_OPLINE();
627 op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
628 op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
629 bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
630 FREE_OP1();
631 FREE_OP2();
632 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
633 }
634
635 ZEND_VM_HANDLER(11, ZEND_BW_XOR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
636 {
637 USE_OPLINE
638 zend_free_op free_op1, free_op2;
639 zval *op1, *op2;
640
641 SAVE_OPLINE();
642 op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
643 op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
644 bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
645 FREE_OP1();
646 FREE_OP2();
647 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
648 }
649
650 ZEND_VM_HANDLER(14, ZEND_BOOL_XOR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
651 {
652 USE_OPLINE
653 zend_free_op free_op1, free_op2;
654 zval *op1, *op2;
655
656 SAVE_OPLINE();
657 op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
658 op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
659 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
660 FREE_OP1();
661 FREE_OP2();
662 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
663 }
664
665 ZEND_VM_HANDLER(12, ZEND_BW_NOT, CONST|TMPVAR|CV, ANY)
666 {
667 USE_OPLINE
668 zend_free_op free_op1;
669
670 SAVE_OPLINE();
671 bitwise_not_function(EX_VAR(opline->result.var),
672 GET_OP1_ZVAL_PTR(BP_VAR_R));
673 FREE_OP1();
674 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
675 }
676
677 ZEND_VM_HANDLER(13, ZEND_BOOL_NOT, CONST|TMPVAR|CV, ANY)
678 {
679 USE_OPLINE
680 zval *val;
681 zend_free_op free_op1;
682
683 val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
684 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
685 ZVAL_FALSE(EX_VAR(opline->result.var));
686 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
687 ZVAL_TRUE(EX_VAR(opline->result.var));
688 if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
689 SAVE_OPLINE();
690 GET_OP1_UNDEF_CV(val, BP_VAR_R);
691 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
692 }
693 } else {
694 SAVE_OPLINE();
695 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
696 FREE_OP1();
697 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
698 }
699 ZEND_VM_NEXT_OPCODE();
700 }
701
702 ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV, binary_op_type binary_op)
703 {
704 USE_OPLINE
705 zend_free_op free_op1, free_op2, free_op_data1;
706 zval *object;
707 zval *property;
708 zval *value;
709 zval *zptr;
710
711 SAVE_OPLINE();
712 object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
713
714 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(object) == NULL)) {
715 zend_throw_error(NULL, "Using $this when not in object context");
716 FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
717 FREE_UNFETCHED_OP2();
718 HANDLE_EXCEPTION();
719 }
720
721 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
722
723 if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) {
724 zend_throw_error(NULL, "Cannot use string offset as an object");
725 FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
726 FREE_OP2();
727 HANDLE_EXCEPTION();
728 }
729
730 do {
731 value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
732
733 if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
734 ZVAL_DEREF(object);
735 if (UNEXPECTED(!make_real_object(object))) {
736 zend_error(E_WARNING, "Attempt to assign property of non-object");
737 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
738 ZVAL_NULL(EX_VAR(opline->result.var));
739 }
740 break;
741 }
742 }
743
744
745 if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
746 && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
747
748 ZVAL_DEREF(zptr);
749 SEPARATE_ZVAL_NOREF(zptr);
750
751 binary_op(zptr, zptr, value);
752 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
753 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
754 }
755 } else {
756 zend_assign_op_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
757 }
758 } while (0);
759
760 FREE_OP(free_op_data1);
761 FREE_OP2();
762 FREE_OP1_VAR_PTR();
763
764 ZEND_VM_NEXT_OPCODE_EX(1, 2);
765 }
766
767 ZEND_VM_HELPER_EX(zend_binary_assign_op_dim_helper, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV, binary_op_type binary_op)
768 {
769 USE_OPLINE
770 zend_free_op free_op1, free_op2, free_op_data1;
771 zval *var_ptr, rv;
772 zval *value, *container, *dim;
773
774 SAVE_OPLINE();
775 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
776 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
777 zend_throw_error(NULL, "Using $this when not in object context");
778 FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
779 FREE_UNFETCHED_OP2();
780 HANDLE_EXCEPTION();
781 }
782 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
783 zend_throw_error(NULL, "Cannot use string offset as an array");
784 FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
785 FREE_UNFETCHED_OP2();
786 HANDLE_EXCEPTION();
787 }
788
789 dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
790
791 do {
792 if (OP1_TYPE == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
793 if (OP1_TYPE != IS_UNUSED) {
794 ZVAL_DEREF(container);
795 }
796 if (OP1_TYPE == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
797 value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
798 zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
799 break;
800 }
801 }
802
803 zend_fetch_dimension_address_RW(&rv, container, dim, OP2_TYPE);
804 value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
805 ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
806 var_ptr = Z_INDIRECT(rv);
807
808 if (UNEXPECTED(var_ptr == NULL)) {
809 zend_throw_error(NULL, "Cannot use assign-op operators with overloaded objects nor string offsets");
810 FREE_OP2();
811 FREE_OP(free_op_data1);
812 FREE_OP1_VAR_PTR();
813 HANDLE_EXCEPTION();
814 }
815
816 if (UNEXPECTED(var_ptr == &EG(error_zval))) {
817 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
818 ZVAL_NULL(EX_VAR(opline->result.var));
819 }
820 } else {
821 ZVAL_DEREF(var_ptr);
822 SEPARATE_ZVAL_NOREF(var_ptr);
823
824 binary_op(var_ptr, var_ptr, value);
825
826 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
827 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
828 }
829 }
830 } while (0);
831
832 FREE_OP2();
833 FREE_OP(free_op_data1);
834 FREE_OP1_VAR_PTR();
835 ZEND_VM_NEXT_OPCODE_EX(1, 2);
836 }
837
838 ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|CV, CONST|TMPVAR|CV, binary_op_type binary_op)
839 {
840 USE_OPLINE
841 zend_free_op free_op1, free_op2;
842 zval *var_ptr;
843 zval *value;
844
845 SAVE_OPLINE();
846 value = GET_OP2_ZVAL_PTR(BP_VAR_R);
847 var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
848
849 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
850 zend_throw_error(NULL, "Cannot use assign-op operators with overloaded objects nor string offsets");
851 FREE_OP2();
852 HANDLE_EXCEPTION();
853 }
854
855 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
856 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
857 ZVAL_NULL(EX_VAR(opline->result.var));
858 }
859 } else {
860 ZVAL_DEREF(var_ptr);
861 SEPARATE_ZVAL_NOREF(var_ptr);
862
863 binary_op(var_ptr, var_ptr, value);
864
865 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
866 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
867 }
868 }
869
870 FREE_OP2();
871 FREE_OP1_VAR_PTR();
872 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
873 }
874
875 ZEND_VM_HANDLER(23, ZEND_ASSIGN_ADD, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
876 {
877 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
878 USE_OPLINE
879
880 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
881 if (EXPECTED(opline->extended_value == 0)) {
882 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, add_function);
883 }
884 # endif
885 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
886 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, add_function);
887 } else {
888 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, add_function);
889 }
890 #else
891 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, add_function);
892 #endif
893 }
894
895 ZEND_VM_HANDLER(24, ZEND_ASSIGN_SUB, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
896 {
897 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
898 USE_OPLINE
899
900 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
901 if (EXPECTED(opline->extended_value == 0)) {
902 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, sub_function);
903 }
904 # endif
905 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
906 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, sub_function);
907 } else {
908 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, sub_function);
909 }
910 #else
911 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, sub_function);
912 #endif
913 }
914
915 ZEND_VM_HANDLER(25, ZEND_ASSIGN_MUL, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
916 {
917 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
918 USE_OPLINE
919
920 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
921 if (EXPECTED(opline->extended_value == 0)) {
922 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mul_function);
923 }
924 # endif
925 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
926 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, mul_function);
927 } else {
928 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, mul_function);
929 }
930 #else
931 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, mul_function);
932 #endif
933 }
934
935 ZEND_VM_HANDLER(26, ZEND_ASSIGN_DIV, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
936 {
937 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
938 USE_OPLINE
939
940 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
941 if (EXPECTED(opline->extended_value == 0)) {
942 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, div_function);
943 }
944 # endif
945 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
946 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, div_function);
947 } else {
948 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, div_function);
949 }
950 #else
951 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, div_function);
952 #endif
953 }
954
955 ZEND_VM_HANDLER(27, ZEND_ASSIGN_MOD, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
956 {
957 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
958 USE_OPLINE
959
960 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
961 if (EXPECTED(opline->extended_value == 0)) {
962 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mod_function);
963 }
964 # endif
965 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
966 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, mod_function);
967 } else {
968 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, mod_function);
969 }
970 #else
971 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, mod_function);
972 #endif
973 }
974
975 ZEND_VM_HANDLER(28, ZEND_ASSIGN_SL, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
976 {
977 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
978 USE_OPLINE
979
980 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
981 if (EXPECTED(opline->extended_value == 0)) {
982 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_left_function);
983 }
984 # endif
985 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
986 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, shift_left_function);
987 } else {
988 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, shift_left_function);
989 }
990 #else
991 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, shift_left_function);
992 #endif
993 }
994
995 ZEND_VM_HANDLER(29, ZEND_ASSIGN_SR, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
996 {
997 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
998 USE_OPLINE
999
1000 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
1001 if (EXPECTED(opline->extended_value == 0)) {
1002 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_right_function);
1003 }
1004 # endif
1005 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
1006 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, shift_right_function);
1007 } else {
1008 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, shift_right_function);
1009 }
1010 #else
1011 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, shift_right_function);
1012 #endif
1013 }
1014
1015 ZEND_VM_HANDLER(30, ZEND_ASSIGN_CONCAT, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
1016 {
1017 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
1018 USE_OPLINE
1019
1020 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
1021 if (EXPECTED(opline->extended_value == 0)) {
1022 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, concat_function);
1023 }
1024 # endif
1025 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
1026 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, concat_function);
1027 } else {
1028 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, concat_function);
1029 }
1030 #else
1031 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, concat_function);
1032 #endif
1033 }
1034
1035 ZEND_VM_HANDLER(31, ZEND_ASSIGN_BW_OR, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
1036 {
1037 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
1038 USE_OPLINE
1039
1040 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
1041 if (EXPECTED(opline->extended_value == 0)) {
1042 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_or_function);
1043 }
1044 # endif
1045 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
1046 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_or_function);
1047 } else {
1048 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, bitwise_or_function);
1049 }
1050 #else
1051 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_or_function);
1052 #endif
1053 }
1054
1055 ZEND_VM_HANDLER(32, ZEND_ASSIGN_BW_AND, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
1056 {
1057 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
1058 USE_OPLINE
1059
1060 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
1061 if (EXPECTED(opline->extended_value == 0)) {
1062 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_and_function);
1063 }
1064 # endif
1065 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
1066 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_and_function);
1067 } else {
1068 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, bitwise_and_function);
1069 }
1070 #else
1071 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_and_function);
1072 #endif
1073 }
1074
1075 ZEND_VM_HANDLER(33, ZEND_ASSIGN_BW_XOR, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
1076 {
1077 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
1078 USE_OPLINE
1079
1080 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
1081 if (EXPECTED(opline->extended_value == 0)) {
1082 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_xor_function);
1083 }
1084 # endif
1085 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
1086 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_xor_function);
1087 } else {
1088 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, bitwise_xor_function);
1089 }
1090 #else
1091 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_xor_function);
1092 #endif
1093 }
1094
1095 ZEND_VM_HANDLER(167, ZEND_ASSIGN_POW, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
1096 {
1097 #if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
1098 USE_OPLINE
1099
1100 # if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
1101 if (EXPECTED(opline->extended_value == 0)) {
1102 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, pow_function);
1103 }
1104 # endif
1105 if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
1106 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, pow_function);
1107 } else {
1108 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, pow_function);
1109 }
1110 #else
1111 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, pow_function);
1112 #endif
1113 }
1114
1115 ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV, int inc)
1116 {
1117 USE_OPLINE
1118 zend_free_op free_op1, free_op2;
1119 zval *object;
1120 zval *property;
1121 zval *zptr;
1122
1123 SAVE_OPLINE();
1124 object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
1125
1126 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(object) == NULL)) {
1127 zend_throw_error(NULL, "Using $this when not in object context");
1128 FREE_UNFETCHED_OP2();
1129 HANDLE_EXCEPTION();
1130 }
1131
1132 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
1133
1134 if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) {
1135 zend_throw_error(NULL, "Cannot increment/decrement overloaded objects nor string offsets");
1136 FREE_OP2();
1137 HANDLE_EXCEPTION();
1138 }
1139
1140 do {
1141 if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
1142 ZVAL_DEREF(object);
1143 if (UNEXPECTED(!make_real_object(object))) {
1144 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
1145 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1146 ZVAL_NULL(EX_VAR(opline->result.var));
1147 }
1148 break;
1149 }
1150 }
1151
1152
1153
1154 if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
1155 && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
1156
1157 if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
1158 if (inc) {
1159 fast_long_increment_function(zptr);
1160 } else {
1161 fast_long_decrement_function(zptr);
1162 }
1163 } else {
1164 ZVAL_DEREF(zptr);
1165 SEPARATE_ZVAL_NOREF(zptr);
1166
1167 if (inc) {
1168 increment_function(zptr);
1169 } else {
1170 decrement_function(zptr);
1171 }
1172 }
1173 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1174 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
1175 }
1176 } else {
1177 zend_pre_incdec_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
1178 }
1179 } while (0);
1180
1181 FREE_OP2();
1182 FREE_OP1_VAR_PTR();
1183 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1184 }
1185
1186 ZEND_VM_HANDLER(132, ZEND_PRE_INC_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
1187 {
1188 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_pre_incdec_property_helper, inc, 1);
1189 }
1190
1191 ZEND_VM_HANDLER(133, ZEND_PRE_DEC_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
1192 {
1193 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_pre_incdec_property_helper, inc, 0);
1194 }
1195
1196 ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV, int inc)
1197 {
1198 USE_OPLINE
1199 zend_free_op free_op1, free_op2;
1200 zval *object;
1201 zval *property;
1202 zval *zptr;
1203
1204 SAVE_OPLINE();
1205 object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
1206
1207 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(object) == NULL)) {
1208 zend_throw_error(NULL, "Using $this when not in object context");
1209 FREE_UNFETCHED_OP2();
1210 HANDLE_EXCEPTION();
1211 }
1212
1213 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
1214
1215 if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) {
1216 zend_throw_error(NULL, "Cannot increment/decrement overloaded objects nor string offsets");
1217 FREE_OP2();
1218 HANDLE_EXCEPTION();
1219 }
1220
1221 do {
1222 if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
1223 ZVAL_DEREF(object);
1224 if (UNEXPECTED(!make_real_object(object))) {
1225 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
1226 ZVAL_NULL(EX_VAR(opline->result.var));
1227 break;
1228 }
1229 }
1230
1231
1232
1233 if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
1234 && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
1235
1236 if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
1237 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), zptr);
1238 if (inc) {
1239 fast_long_increment_function(zptr);
1240 } else {
1241 fast_long_decrement_function(zptr);
1242 }
1243 } else {
1244 ZVAL_DEREF(zptr);
1245 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), zptr);
1246 zval_opt_copy_ctor(zptr);
1247 if (inc) {
1248 increment_function(zptr);
1249 } else {
1250 decrement_function(zptr);
1251 }
1252 }
1253 } else {
1254 zend_post_incdec_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
1255 }
1256 } while (0);
1257
1258 FREE_OP2();
1259 FREE_OP1_VAR_PTR();
1260 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1261 }
1262
1263 ZEND_VM_HANDLER(134, ZEND_POST_INC_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
1264 {
1265 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_post_incdec_property_helper, inc, 1);
1266 }
1267
1268 ZEND_VM_HANDLER(135, ZEND_POST_DEC_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
1269 {
1270 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_post_incdec_property_helper, inc, 0);
1271 }
1272
1273 ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
1274 {
1275 USE_OPLINE
1276 zend_free_op free_op1;
1277 zval *var_ptr;
1278
1279 var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
1280
1281 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
1282 SAVE_OPLINE();
1283 zend_throw_error(NULL, "Cannot increment/decrement overloaded objects nor string offsets");
1284 HANDLE_EXCEPTION();
1285 }
1286
1287 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
1288 fast_long_increment_function(var_ptr);
1289 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1290 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
1291 }
1292 ZEND_VM_NEXT_OPCODE();
1293 }
1294
1295 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
1296 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1297 ZVAL_NULL(EX_VAR(opline->result.var));
1298 }
1299 ZEND_VM_NEXT_OPCODE();
1300 }
1301
1302 SAVE_OPLINE();
1303 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
1304 var_ptr = GET_OP1_UNDEF_CV(var_ptr, BP_VAR_RW);
1305 }
1306 ZVAL_DEREF(var_ptr);
1307 SEPARATE_ZVAL_NOREF(var_ptr);
1308
1309 increment_function(var_ptr);
1310
1311 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1312 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
1313 }
1314
1315 FREE_OP1_VAR_PTR();
1316 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1317 }
1318
1319 ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
1320 {
1321 USE_OPLINE
1322 zend_free_op free_op1;
1323 zval *var_ptr;
1324
1325 var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
1326
1327 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
1328 SAVE_OPLINE();
1329 zend_throw_error(NULL, "Cannot increment/decrement overloaded objects nor string offsets");
1330 HANDLE_EXCEPTION();
1331 }
1332
1333 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
1334 fast_long_decrement_function(var_ptr);
1335 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1336 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
1337 }
1338 ZEND_VM_NEXT_OPCODE();
1339 }
1340
1341 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
1342 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1343 ZVAL_NULL(EX_VAR(opline->result.var));
1344 }
1345 ZEND_VM_NEXT_OPCODE();
1346 }
1347
1348 SAVE_OPLINE();
1349 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
1350 var_ptr = GET_OP1_UNDEF_CV(var_ptr, BP_VAR_RW);
1351 }
1352 ZVAL_DEREF(var_ptr);
1353 SEPARATE_ZVAL_NOREF(var_ptr);
1354
1355 decrement_function(var_ptr);
1356
1357 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1358 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
1359 }
1360
1361 FREE_OP1_VAR_PTR();
1362 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1363 }
1364
1365 ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
1366 {
1367 USE_OPLINE
1368 zend_free_op free_op1;
1369 zval *var_ptr;
1370
1371 var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
1372
1373 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
1374 SAVE_OPLINE();
1375 zend_throw_error(NULL, "Cannot increment/decrement overloaded objects nor string offsets");
1376 HANDLE_EXCEPTION();
1377 }
1378
1379 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
1380 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
1381 fast_long_increment_function(var_ptr);
1382 ZEND_VM_NEXT_OPCODE();
1383 }
1384
1385 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
1386 ZVAL_NULL(EX_VAR(opline->result.var));
1387 ZEND_VM_NEXT_OPCODE();
1388 }
1389
1390 SAVE_OPLINE();
1391 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
1392 var_ptr = GET_OP1_UNDEF_CV(var_ptr, BP_VAR_RW);
1393 }
1394 ZVAL_DEREF(var_ptr);
1395 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
1396 zval_opt_copy_ctor(var_ptr);
1397
1398 increment_function(var_ptr);
1399
1400 FREE_OP1_VAR_PTR();
1401 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1402 }
1403
1404 ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
1405 {
1406 USE_OPLINE
1407 zend_free_op free_op1;
1408 zval *var_ptr;
1409
1410 var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
1411
1412 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
1413 SAVE_OPLINE();
1414 zend_throw_error(NULL, "Cannot increment/decrement overloaded objects nor string offsets");
1415 HANDLE_EXCEPTION();
1416 }
1417
1418 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
1419 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
1420 fast_long_decrement_function(var_ptr);
1421 ZEND_VM_NEXT_OPCODE();
1422 }
1423
1424 if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
1425 ZVAL_NULL(EX_VAR(opline->result.var));
1426 ZEND_VM_NEXT_OPCODE();
1427 }
1428
1429 SAVE_OPLINE();
1430 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
1431 var_ptr = GET_OP1_UNDEF_CV(var_ptr, BP_VAR_RW);
1432 }
1433 ZVAL_DEREF(var_ptr);
1434 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
1435 zval_opt_copy_ctor(var_ptr);
1436
1437 decrement_function(var_ptr);
1438
1439 FREE_OP1_VAR_PTR();
1440 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1441 }
1442
1443 ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMPVAR|CV, ANY)
1444 {
1445 USE_OPLINE
1446 zend_free_op free_op1;
1447 zval *z;
1448
1449 SAVE_OPLINE();
1450 z = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
1451
1452 if (Z_TYPE_P(z) == IS_STRING) {
1453 zend_string *str = Z_STR_P(z);
1454
1455 if (ZSTR_LEN(str) != 0) {
1456 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
1457 }
1458 } else {
1459 zend_string *str = _zval_get_string_func(z);
1460
1461 if (ZSTR_LEN(str) != 0) {
1462 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
1463 } else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
1464 GET_OP1_UNDEF_CV(z, BP_VAR_R);
1465 }
1466 zend_string_release(str);
1467 }
1468
1469 FREE_OP1();
1470 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1471 }
1472
1473 ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMPVAR|CV, UNUSED|CONST|VAR, int type)
1474 {
1475 USE_OPLINE
1476 zend_free_op free_op1;
1477 zval *varname;
1478 zval *retval;
1479 zend_string *name;
1480 HashTable *target_symbol_table;
1481
1482 SAVE_OPLINE();
1483 varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
1484
1485 if (OP1_TYPE == IS_CONST) {
1486 name = Z_STR_P(varname);
1487 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
1488 name = Z_STR_P(varname);
1489 zend_string_addref(name);
1490 } else {
1491 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
1492 GET_OP1_UNDEF_CV(varname, BP_VAR_R);
1493 }
1494 name = zval_get_string(varname);
1495 }
1496
1497 if (OP2_TYPE != IS_UNUSED) {
1498 zend_class_entry *ce;
1499
1500 if (OP2_TYPE == IS_CONST) {
1501 if (OP1_TYPE == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) != NULL)) {
1502 retval = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)) + sizeof(void*));
1503
1504
1505 if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
1506 zend_throw_error(NULL, "Access to undeclared static property: %s::$%s", ZSTR_VAL(ce->name), ZSTR_VAL(name));
1507 FREE_OP1();
1508 HANDLE_EXCEPTION();
1509 }
1510
1511 ZEND_VM_C_GOTO(fetch_var_return);
1512 } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) == NULL)) {
1513 ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
1514 if (UNEXPECTED(ce == NULL)) {
1515 if (OP1_TYPE != IS_CONST) {
1516 zend_string_release(name);
1517 }
1518 FREE_OP1();
1519 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1520 }
1521 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
1522 }
1523 } else {
1524 ce = Z_CE_P(EX_VAR(opline->op2.var));
1525 if (OP1_TYPE == IS_CONST &&
1526 (retval = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce)) != NULL) {
1527
1528
1529 if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
1530 zend_throw_error(NULL, "Access to undeclared static property: %s::$%s", ZSTR_VAL(ce->name), ZSTR_VAL(name));
1531 FREE_OP1();
1532 HANDLE_EXCEPTION();
1533 }
1534
1535 ZEND_VM_C_GOTO(fetch_var_return);
1536 }
1537 }
1538 retval = zend_std_get_static_property(ce, name, 0);
1539 if (UNEXPECTED(EG(exception))) {
1540 if (OP1_TYPE != IS_CONST) {
1541 zend_string_release(name);
1542 }
1543 FREE_OP1();
1544 HANDLE_EXCEPTION();
1545 }
1546 if (OP1_TYPE == IS_CONST && retval) {
1547 CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce, retval);
1548 }
1549
1550 FREE_OP1();
1551 } else {
1552 target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
1553 retval = zend_hash_find(target_symbol_table, name);
1554 if (retval == NULL) {
1555 switch (type) {
1556 case BP_VAR_R:
1557 case BP_VAR_UNSET:
1558 zend_error(E_NOTICE,"Undefined variable: %s", ZSTR_VAL(name));
1559
1560 case BP_VAR_IS:
1561 retval = &EG(uninitialized_zval);
1562 break;
1563 case BP_VAR_RW:
1564 zend_error(E_NOTICE,"Undefined variable: %s", ZSTR_VAL(name));
1565 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
1566 break;
1567 case BP_VAR_W:
1568 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
1569 break;
1570 EMPTY_SWITCH_DEFAULT_CASE()
1571 }
1572
1573 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
1574 retval = Z_INDIRECT_P(retval);
1575 if (Z_TYPE_P(retval) == IS_UNDEF) {
1576 switch (type) {
1577 case BP_VAR_R:
1578 case BP_VAR_UNSET:
1579 zend_error(E_NOTICE,"Undefined variable: %s", ZSTR_VAL(name));
1580
1581 case BP_VAR_IS:
1582 retval = &EG(uninitialized_zval);
1583 break;
1584 case BP_VAR_RW:
1585 zend_error(E_NOTICE,"Undefined variable: %s", ZSTR_VAL(name));
1586
1587 case BP_VAR_W:
1588 ZVAL_NULL(retval);
1589 break;
1590 EMPTY_SWITCH_DEFAULT_CASE()
1591 }
1592 }
1593 }
1594 if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
1595 if (Z_CONSTANT_P(retval)) {
1596 if (UNEXPECTED(zval_update_constant_ex(retval, 1, NULL) != SUCCESS)) {
1597 FREE_OP1();
1598 HANDLE_EXCEPTION();
1599 }
1600 }
1601 } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
1602 FREE_OP1();
1603 }
1604 }
1605
1606 if (OP1_TYPE != IS_CONST) {
1607 zend_string_release(name);
1608 }
1609
1610 ZEND_VM_C_LABEL(fetch_var_return):
1611 ZEND_ASSERT(retval != NULL);
1612 if (type == BP_VAR_R || type == BP_VAR_IS) {
1613 if ( Z_ISREF_P(retval) && Z_REFCOUNT_P(retval) == 1) {
1614 ZVAL_UNREF(retval);
1615 }
1616 ZVAL_COPY(EX_VAR(opline->result.var), retval);
1617 } else {
1618 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
1619 }
1620 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1621 }
1622
1623 ZEND_VM_HANDLER(80, ZEND_FETCH_R, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
1624 {
1625 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_R);
1626 }
1627
1628 ZEND_VM_HANDLER(83, ZEND_FETCH_W, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
1629 {
1630 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_W);
1631 }
1632
1633 ZEND_VM_HANDLER(86, ZEND_FETCH_RW, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
1634 {
1635 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_RW);
1636 }
1637
1638 ZEND_VM_HANDLER(92, ZEND_FETCH_FUNC_ARG, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
1639 {
1640 USE_OPLINE
1641
1642 if (zend_is_by_ref_func_arg_fetch(opline, EX(call))) {
1643 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_W);
1644 } else {
1645 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_R);
1646 }
1647 }
1648
1649 ZEND_VM_HANDLER(95, ZEND_FETCH_UNSET, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
1650 {
1651 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_UNSET);
1652 }
1653
1654 ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
1655 {
1656 ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_IS);
1657 }
1658
1659 ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
1660 {
1661 USE_OPLINE
1662 zend_free_op free_op1, free_op2;
1663 zval *container;
1664
1665 SAVE_OPLINE();
1666 container = GET_OP1_ZVAL_PTR(BP_VAR_R);
1667 zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
1668 FREE_OP2();
1669 FREE_OP1();
1670 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1671 }
1672
1673 ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMPVAR|UNUSED|CV)
1674 {
1675 USE_OPLINE
1676 zend_free_op free_op1, free_op2;
1677 zval *container;
1678
1679 SAVE_OPLINE();
1680 container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
1681
1682 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1683 zend_throw_error(NULL, "Cannot use string offset as an array");
1684 HANDLE_EXCEPTION();
1685 }
1686 zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
1687 FREE_OP2();
1688 if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
1689 EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var), 1);
1690 }
1691 FREE_OP1_VAR_PTR();
1692 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1693 }
1694
1695 ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMPVAR|UNUSED|CV)
1696 {
1697 USE_OPLINE
1698 zend_free_op free_op1, free_op2;
1699 zval *container;
1700
1701 SAVE_OPLINE();
1702 container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
1703
1704 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1705 zend_throw_error(NULL, "Cannot use string offset as an array");
1706 HANDLE_EXCEPTION();
1707 }
1708 zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
1709 FREE_OP2();
1710 if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
1711 EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var), 1);
1712 }
1713 FREE_OP1_VAR_PTR();
1714 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1715 }
1716
1717 ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
1718 {
1719 USE_OPLINE
1720 zend_free_op free_op1, free_op2;
1721 zval *container;
1722
1723 SAVE_OPLINE();
1724 container = GET_OP1_ZVAL_PTR(BP_VAR_IS);
1725 zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
1726 FREE_OP2();
1727 FREE_OP1();
1728 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1729 }
1730
1731 ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUSED|CV)
1732 {
1733 USE_OPLINE
1734 zval *container;
1735 zend_free_op free_op1, free_op2;
1736
1737 SAVE_OPLINE();
1738
1739 if (zend_is_by_ref_func_arg_fetch(opline, EX(call))) {
1740 if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
1741 zend_throw_error(NULL, "Cannot use temporary expression in write context");
1742 FREE_UNFETCHED_OP2();
1743 FREE_UNFETCHED_OP1();
1744 HANDLE_EXCEPTION();
1745 }
1746 container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
1747 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1748 zend_throw_error(NULL, "Cannot use string offset as an array");
1749 FREE_UNFETCHED_OP2();
1750 HANDLE_EXCEPTION();
1751 }
1752 zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
1753 if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
1754 EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var), 1);
1755 }
1756 FREE_OP2();
1757 FREE_OP1_VAR_PTR();
1758 } else {
1759 if (OP2_TYPE == IS_UNUSED) {
1760 zend_throw_error(NULL, "Cannot use [] for reading");
1761 FREE_UNFETCHED_OP2();
1762 FREE_UNFETCHED_OP1();
1763 HANDLE_EXCEPTION();
1764 }
1765 container = GET_OP1_ZVAL_PTR(BP_VAR_R);
1766 zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
1767 FREE_OP2();
1768 FREE_OP1();
1769 }
1770 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1771 }
1772
1773 ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMPVAR|CV)
1774 {
1775 USE_OPLINE
1776 zend_free_op free_op1, free_op2;
1777 zval *container;
1778
1779 SAVE_OPLINE();
1780 container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_UNSET);
1781
1782 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1783 zend_throw_error(NULL, "Cannot use string offset as an array");
1784 FREE_UNFETCHED_OP2();
1785 HANDLE_EXCEPTION();
1786 }
1787 zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
1788 FREE_OP2();
1789 if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
1790 EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var), 1);
1791 }
1792 FREE_OP1_VAR_PTR();
1793 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1794 }
1795
1796 ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMP|VAR|UNUSED|CV, CONST|TMPVAR|CV)
1797 {
1798 USE_OPLINE
1799 zend_free_op free_op1;
1800 zval *container;
1801 zend_free_op free_op2;
1802 zval *offset;
1803
1804 SAVE_OPLINE();
1805 container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
1806
1807 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
1808 zend_throw_error(NULL, "Using $this when not in object context");
1809 FREE_UNFETCHED_OP2();
1810 HANDLE_EXCEPTION();
1811 }
1812
1813 offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
1814
1815 if (OP1_TYPE == IS_CONST ||
1816 (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
1817 if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
1818 container = Z_REFVAL_P(container);
1819 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
1820 ZEND_VM_C_GOTO(fetch_obj_r_no_object);
1821 }
1822 } else {
1823 ZEND_VM_C_GOTO(fetch_obj_r_no_object);
1824 }
1825 }
1826
1827
1828 do {
1829 zend_object *zobj = Z_OBJ_P(container);
1830 zval *retval;
1831
1832 if (OP2_TYPE == IS_CONST &&
1833 EXPECTED(zobj->ce == CACHED_PTR(Z_CACHE_SLOT_P(offset)))) {
1834 uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(offset) + sizeof(void*));
1835
1836 if (EXPECTED(prop_offset != (uint32_t)ZEND_DYNAMIC_PROPERTY_OFFSET)) {
1837 retval = OBJ_PROP(zobj, prop_offset);
1838 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
1839 ZVAL_COPY(EX_VAR(opline->result.var), retval);
1840 break;
1841 }
1842 } else if (EXPECTED(zobj->properties != NULL)) {
1843 retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
1844 if (EXPECTED(retval)) {
1845 ZVAL_COPY(EX_VAR(opline->result.var), retval);
1846 break;
1847 }
1848 }
1849 }
1850
1851 if (UNEXPECTED(zobj->handlers->read_property == NULL)) {
1852 ZEND_VM_C_LABEL(fetch_obj_r_no_object):
1853 zend_error(E_NOTICE, "Trying to get property of non-object");
1854 ZVAL_NULL(EX_VAR(opline->result.var));
1855 } else {
1856 retval = zobj->handlers->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var));
1857
1858 if (retval != EX_VAR(opline->result.var)) {
1859 ZVAL_COPY(EX_VAR(opline->result.var), retval);
1860 }
1861 }
1862 } while (0);
1863
1864 FREE_OP2();
1865 FREE_OP1();
1866 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1867 }
1868
1869 ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|CV, CONST|TMPVAR|CV)
1870 {
1871 USE_OPLINE
1872 zend_free_op free_op1, free_op2;
1873 zval *property;
1874 zval *container;
1875
1876 SAVE_OPLINE();
1877 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
1878
1879 container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
1880 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
1881 zend_throw_error(NULL, "Using $this when not in object context");
1882 FREE_OP2();
1883 HANDLE_EXCEPTION();
1884 }
1885 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1886 zend_throw_error(NULL, "Cannot use string offset as an object");
1887 FREE_OP2();
1888 HANDLE_EXCEPTION();
1889 }
1890
1891 zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
1892 FREE_OP2();
1893 if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
1894 EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var), 0);
1895 }
1896 FREE_OP1_VAR_PTR();
1897 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1898 }
1899
1900 ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|CV, CONST|TMPVAR|CV)
1901 {
1902 USE_OPLINE
1903 zend_free_op free_op1, free_op2;
1904 zval *property;
1905 zval *container;
1906
1907 SAVE_OPLINE();
1908 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
1909 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
1910
1911 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
1912 zend_throw_error(NULL, "Using $this when not in object context");
1913 FREE_OP2();
1914 HANDLE_EXCEPTION();
1915 }
1916 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
1917 zend_throw_error(NULL, "Cannot use string offset as an object");
1918 FREE_OP2();
1919 HANDLE_EXCEPTION();
1920 }
1921 zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
1922 FREE_OP2();
1923 if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
1924 EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var), 0);
1925 }
1926 FREE_OP1_VAR_PTR();
1927 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
1928 }
1929
1930 ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, CONST|TMPVAR|UNUSED|CV, CONST|TMPVAR|CV)
1931 {
1932 USE_OPLINE
1933 zend_free_op free_op1;
1934 zval *container;
1935 zend_free_op free_op2;
1936 zval *offset;
1937
1938 SAVE_OPLINE();
1939 container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
1940
1941 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
1942 zend_throw_error(NULL, "Using $this when not in object context");
1943 FREE_UNFETCHED_OP2();
1944 HANDLE_EXCEPTION();
1945 }
1946
1947 offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
1948
1949 if (OP1_TYPE == IS_CONST ||
1950 (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
1951 if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
1952 container = Z_REFVAL_P(container);
1953 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
1954 ZEND_VM_C_GOTO(fetch_obj_is_no_object);
1955 }
1956 } else {
1957 ZEND_VM_C_GOTO(fetch_obj_is_no_object);
1958 }
1959 }
1960
1961
1962 do {
1963 zend_object *zobj = Z_OBJ_P(container);
1964 zval *retval;
1965
1966 if (OP2_TYPE == IS_CONST &&
1967 EXPECTED(zobj->ce == CACHED_PTR(Z_CACHE_SLOT_P(offset)))) {
1968 uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(offset) + sizeof(void*));
1969
1970 if (EXPECTED(prop_offset != (uint32_t)ZEND_DYNAMIC_PROPERTY_OFFSET)) {
1971 retval = OBJ_PROP(zobj, prop_offset);
1972 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
1973 ZVAL_COPY(EX_VAR(opline->result.var), retval);
1974 break;
1975 }
1976 } else if (EXPECTED(zobj->properties != NULL)) {
1977 retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
1978 if (EXPECTED(retval)) {
1979 ZVAL_COPY(EX_VAR(opline->result.var), retval);
1980 break;
1981 }
1982 }
1983 }
1984
1985 if (UNEXPECTED(zobj->handlers->read_property == NULL)) {
1986 ZEND_VM_C_LABEL(fetch_obj_is_no_object):
1987 ZVAL_NULL(EX_VAR(opline->result.var));
1988 } else {
1989
1990 retval = zobj->handlers->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var));
1991
1992 if (retval != EX_VAR(opline->result.var)) {
1993 ZVAL_COPY(EX_VAR(opline->result.var), retval);
1994 }
1995 }
1996 } while (0);
1997
1998 FREE_OP2();
1999 FREE_OP1();
2000 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2001 }
2002
2003 ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, CONST|TMP|VAR|UNUSED|CV, CONST|TMPVAR|CV)
2004 {
2005 USE_OPLINE
2006 zval *container;
2007
2008 if (zend_is_by_ref_func_arg_fetch(opline, EX(call))) {
2009
2010 zend_free_op free_op1, free_op2;
2011 zval *property;
2012
2013 SAVE_OPLINE();
2014 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
2015 container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
2016
2017 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
2018 zend_throw_error(NULL, "Using $this when not in object context");
2019 FREE_OP2();
2020 HANDLE_EXCEPTION();
2021 }
2022 if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
2023 zend_throw_error(NULL, "Cannot use temporary expression in write context");
2024 FREE_OP2();
2025 FREE_OP1_VAR_PTR();
2026 HANDLE_EXCEPTION();
2027 }
2028 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
2029 zend_throw_error(NULL, "Cannot use string offset as an object");
2030 FREE_OP2();
2031 HANDLE_EXCEPTION();
2032 }
2033 zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
2034 FREE_OP2();
2035 if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
2036 EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var), 0);
2037 }
2038 FREE_OP1_VAR_PTR();
2039 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2040 } else {
2041 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_FETCH_OBJ_R);
2042 }
2043 }
2044
2045 ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|CV, CONST|TMPVAR|CV)
2046 {
2047 USE_OPLINE
2048 zend_free_op free_op1, free_op2;
2049 zval *container, *property;
2050
2051 SAVE_OPLINE();
2052 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
2053
2054 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
2055 zend_throw_error(NULL, "Using $this when not in object context");
2056 FREE_UNFETCHED_OP2();
2057 HANDLE_EXCEPTION();
2058 }
2059
2060 property = GET_OP2_ZVAL_PTR(BP_VAR_R);
2061
2062 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
2063 zend_throw_error(NULL, "Cannot use string offset as an object");
2064 FREE_OP2();
2065 HANDLE_EXCEPTION();
2066 }
2067 zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
2068 FREE_OP2();
2069 if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
2070 EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var), 0);
2071 }
2072 FREE_OP1_VAR_PTR();
2073 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2074 }
2075
2076 ZEND_VM_HANDLER(98, ZEND_FETCH_LIST, CONST|TMPVAR|CV, CONST)
2077 {
2078 USE_OPLINE
2079 zend_free_op free_op1;
2080 zval *container;
2081
2082 SAVE_OPLINE();
2083 container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
2084
2085 ZEND_VM_C_LABEL(try_fetch_list):
2086 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
2087 zval *value = zend_hash_index_find(Z_ARRVAL_P(container), Z_LVAL_P(EX_CONSTANT(opline->op2)));
2088
2089 if (UNEXPECTED(value == NULL)) {
2090 zend_error(E_NOTICE,"Undefined offset: " ZEND_ULONG_FMT, Z_LVAL_P(EX_CONSTANT(opline->op2)));
2091 ZVAL_NULL(EX_VAR(opline->result.var));
2092 } else {
2093 ZVAL_COPY(EX_VAR(opline->result.var), value);
2094 }
2095 } else if (OP1_TYPE != IS_CONST &&
2096 UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) &&
2097 EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) {
2098 zval *result = EX_VAR(opline->result.var);
2099 zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, EX_CONSTANT(opline->op2), BP_VAR_R, result);
2100
2101 if (retval) {
2102 if (result != retval) {
2103 ZVAL_COPY(result, retval);
2104 }
2105 } else {
2106 ZVAL_NULL(result);
2107 }
2108 } else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) {
2109 container = Z_REFVAL_P(container);
2110 ZEND_VM_C_GOTO(try_fetch_list);
2111 } else {
2112 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
2113 GET_OP1_UNDEF_CV(container, BP_VAR_R);
2114 }
2115 ZVAL_NULL(EX_VAR(opline->result.var));
2116 }
2117 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2118 }
2119
2120 ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
2121 {
2122 USE_OPLINE
2123 zend_free_op free_op1, free_op2;
2124 zval *object;
2125 zval *property_name;
2126
2127 SAVE_OPLINE();
2128 object = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
2129
2130 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(object) == NULL)) {
2131 zend_throw_error(NULL, "Using $this when not in object context");
2132 FREE_UNFETCHED_OP2();
2133 HANDLE_EXCEPTION();
2134 }
2135
2136 property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
2137
2138 if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) {
2139 zend_throw_error(NULL, "Cannot use string offset as an array");
2140 FREE_OP2();
2141 HANDLE_EXCEPTION();
2142 }
2143 zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, OP1_TYPE, property_name, OP2_TYPE, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property_name)) : NULL));
2144 FREE_OP2();
2145 FREE_OP1_VAR_PTR();
2146
2147 ZEND_VM_NEXT_OPCODE_EX(1, 2);
2148 }
2149
2150 ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMPVAR|UNUSED|CV)
2151 {
2152 USE_OPLINE
2153 zend_free_op free_op1;
2154 zval *object_ptr;
2155 zend_free_op free_op2, free_op_data1;
2156 zval *value;
2157 zval *variable_ptr;
2158 zval *dim;
2159
2160 SAVE_OPLINE();
2161 object_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
2162
2163 if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
2164 zend_throw_error(NULL, "Cannot use string offset as an array");
2165 FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
2166 FREE_UNFETCHED_OP2();
2167 HANDLE_EXCEPTION();
2168 }
2169
2170 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
2171 ZEND_VM_C_LABEL(try_assign_dim_array):
2172 if (OP2_TYPE == IS_UNUSED) {
2173 SEPARATE_ARRAY(object_ptr);
2174 variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
2175 if (UNEXPECTED(variable_ptr == NULL)) {
2176 zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
2177 variable_ptr = &EG(error_zval);
2178 }
2179 } else {
2180 dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
2181 SEPARATE_ARRAY(object_ptr);
2182 variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, OP2_TYPE, BP_VAR_W);
2183 FREE_OP2();
2184 }
2185 value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
2186 if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
2187 FREE_OP(free_op_data1);
2188 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
2189 ZVAL_NULL(EX_VAR(opline->result.var));
2190 }
2191 } else {
2192 value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type);
2193 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
2194 ZVAL_COPY(EX_VAR(opline->result.var), value);
2195 }
2196 }
2197 } else {
2198 if (EXPECTED(Z_ISREF_P(object_ptr))) {
2199 object_ptr = Z_REFVAL_P(object_ptr);
2200 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
2201 ZEND_VM_C_GOTO(try_assign_dim_array);
2202 }
2203 }
2204 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
2205 zend_free_op free_op2;
2206 zval *property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
2207
2208 zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, (opline+1)->op1_type, (opline+1)->op1, execute_data);
2209 FREE_OP2();
2210 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
2211 if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) {
2212 if (OP2_TYPE == IS_UNUSED) {
2213 zend_throw_error(NULL, "[] operator not supported for strings");
2214 FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
2215 FREE_OP1_VAR_PTR();
2216 HANDLE_EXCEPTION();
2217 } else {
2218 zend_long offset;
2219
2220 dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
2221 offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
2222 FREE_OP2();
2223 value = get_zval_ptr_r_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
2224 zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
2225 FREE_OP(free_op_data1);
2226 }
2227 } else {
2228 zval_ptr_dtor_nogc(object_ptr);
2229 ZEND_VM_C_LABEL(assign_dim_convert_to_array):
2230 ZVAL_NEW_ARR(object_ptr);
2231 zend_hash_init(Z_ARRVAL_P(object_ptr), 8, NULL, ZVAL_PTR_DTOR, 0);
2232 ZEND_VM_C_GOTO(try_assign_dim_array);
2233 }
2234 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
2235 if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == &EG(error_zval))) {
2236 ZEND_VM_C_GOTO(assign_dim_clean);
2237 }
2238 ZEND_VM_C_GOTO(assign_dim_convert_to_array);
2239 } else {
2240 zend_error(E_WARNING, "Cannot use a scalar value as an array");
2241 ZEND_VM_C_LABEL(assign_dim_clean):
2242 dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
2243 FREE_OP2();
2244 value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
2245 FREE_OP(free_op_data1);
2246 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
2247 ZVAL_NULL(EX_VAR(opline->result.var));
2248 }
2249 }
2250 }
2251 FREE_OP1_VAR_PTR();
2252
2253 ZEND_VM_NEXT_OPCODE_EX(1, 2);
2254 }
2255
2256 ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
2257 {
2258 USE_OPLINE
2259 zend_free_op free_op1, free_op2;
2260 zval *value;
2261 zval *variable_ptr;
2262
2263 SAVE_OPLINE();
2264 value = GET_OP2_ZVAL_PTR(BP_VAR_R);
2265 variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
2266
2267 if (OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
2268 FREE_OP2();
2269 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
2270 ZVAL_NULL(EX_VAR(opline->result.var));
2271 }
2272 } else {
2273 value = zend_assign_to_variable(variable_ptr, value, OP2_TYPE);
2274 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
2275 ZVAL_COPY(EX_VAR(opline->result.var), value);
2276 }
2277 FREE_OP1_VAR_PTR();
2278
2279 }
2280
2281 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2282 }
2283
2284 ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV)
2285 {
2286 USE_OPLINE
2287 zend_free_op free_op1, free_op2;
2288 zval *variable_ptr;
2289 zval *value_ptr;
2290
2291 SAVE_OPLINE();
2292 value_ptr = GET_OP2_ZVAL_PTR_PTR(BP_VAR_W);
2293
2294 if (OP2_TYPE == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
2295 zend_throw_error(NULL, "Cannot create references to/from string offsets nor overloaded objects");
2296 FREE_UNFETCHED_OP1();
2297 HANDLE_EXCEPTION();
2298 }
2299 if (OP1_TYPE == IS_VAR &&
2300 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
2301 UNEXPECTED(!Z_ISREF_P(EX_VAR(opline->op1.var)))) {
2302 zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
2303 FREE_OP2_VAR_PTR();
2304 HANDLE_EXCEPTION();
2305 }
2306 if (OP2_TYPE == IS_VAR &&
2307 (value_ptr == &EG(uninitialized_zval) ||
2308 (opline->extended_value == ZEND_RETURNS_FUNCTION &&
2309 !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) {
2310 if (!OP2_FREE && UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op2.var)) != IS_INDIRECT)) {
2311 Z_TRY_ADDREF_P(value_ptr);
2312 }
2313 zend_error(E_NOTICE, "Only variables should be assigned by reference");
2314 if (UNEXPECTED(EG(exception) != NULL)) {
2315 FREE_OP2_VAR_PTR();
2316 HANDLE_EXCEPTION();
2317 }
2318 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ASSIGN);
2319 }
2320
2321 variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
2322 if (OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr == NULL)) {
2323 zend_throw_error(NULL, "Cannot create references to/from string offsets nor overloaded objects");
2324 FREE_OP2_VAR_PTR();
2325 HANDLE_EXCEPTION();
2326 }
2327 if ((OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
2328 (OP2_TYPE == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
2329 variable_ptr = &EG(uninitialized_zval);
2330 } else {
2331 zend_assign_to_variable_reference(variable_ptr, value_ptr);
2332 }
2333
2334 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
2335 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
2336 }
2337
2338 FREE_OP1_VAR_PTR();
2339 FREE_OP2_VAR_PTR();
2340
2341 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2342 }
2343
2344 ZEND_VM_HELPER(zend_leave_helper, ANY, ANY)
2345 {
2346 zend_execute_data *old_execute_data;
2347 uint32_t call_info = EX_CALL_INFO();
2348
2349 if (EXPECTED(ZEND_CALL_KIND_EX(call_info) == ZEND_CALL_NESTED_FUNCTION)) {
2350 zend_object *object;
2351
2352 i_free_compiled_variables(execute_data);
2353 if (UNEXPECTED(EX(symbol_table) != NULL)) {
2354 zend_clean_and_cache_symbol_table(EX(symbol_table));
2355 }
2356 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
2357 old_execute_data = execute_data;
2358 execute_data = EG(current_execute_data) = EX(prev_execute_data);
2359 if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
2360 OBJ_RELEASE((zend_object*)old_execute_data->func->op_array.prototype);
2361 }
2362 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
2363 object = Z_OBJ(old_execute_data->This);
2364 #if 0
2365 if (UNEXPECTED(EG(exception) != NULL) && (EX(opline)->op1.num & ZEND_CALL_CTOR)) {
2366 if (!(EX(opline)->op1.num & ZEND_CALL_CTOR_RESULT_UNUSED)) {
2367 #else
2368 if (UNEXPECTED(EG(exception) != NULL) && (call_info & ZEND_CALL_CTOR)) {
2369 if (!(call_info & ZEND_CALL_CTOR_RESULT_UNUSED)) {
2370 #endif
2371 GC_REFCOUNT(object)--;
2372 }
2373 if (GC_REFCOUNT(object) == 1) {
2374 zend_object_store_ctor_failed(object);
2375 }
2376 }
2377 OBJ_RELEASE(object);
2378 }
2379 EG(scope) = EX(func)->op_array.scope;
2380
2381 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
2382
2383 if (UNEXPECTED(EG(exception) != NULL)) {
2384 const zend_op *old_opline = EX(opline);
2385 zend_throw_exception_internal(NULL);
2386 if (old_opline->opcode != ZEND_HANDLE_EXCEPTION && RETURN_VALUE_USED(old_opline)) {
2387 zval_ptr_dtor(EX_VAR(old_opline->result.var));
2388 }
2389 HANDLE_EXCEPTION_LEAVE();
2390 }
2391
2392 LOAD_NEXT_OPLINE();
2393 ZEND_VM_LEAVE();
2394 }
2395 if (EXPECTED((ZEND_CALL_KIND_EX(call_info) & ZEND_CALL_TOP) == 0)) {
2396 zend_detach_symbol_table(execute_data);
2397 destroy_op_array(&EX(func)->op_array);
2398 efree_size(EX(func), sizeof(zend_op_array));
2399 old_execute_data = execute_data;
2400 execute_data = EG(current_execute_data) = EX(prev_execute_data);
2401 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
2402
2403 zend_attach_symbol_table(execute_data);
2404 if (UNEXPECTED(EG(exception) != NULL)) {
2405 zend_throw_exception_internal(NULL);
2406 HANDLE_EXCEPTION_LEAVE();
2407 }
2408
2409 LOAD_NEXT_OPLINE();
2410 ZEND_VM_LEAVE();
2411 } else {
2412 if (ZEND_CALL_KIND_EX(call_info) == ZEND_CALL_TOP_FUNCTION) {
2413 i_free_compiled_variables(execute_data);
2414 if (UNEXPECTED(EX(symbol_table) != NULL)) {
2415 zend_clean_and_cache_symbol_table(EX(symbol_table));
2416 }
2417 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
2418 EG(current_execute_data) = EX(prev_execute_data);
2419 if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
2420 OBJ_RELEASE((zend_object*)EX(func)->op_array.prototype);
2421 }
2422 } else {
2423 zend_array *symbol_table = EX(symbol_table);
2424
2425 zend_detach_symbol_table(execute_data);
2426 old_execute_data = EX(prev_execute_data);
2427 while (old_execute_data) {
2428 if (old_execute_data->func && ZEND_USER_CODE(old_execute_data->func->op_array.type)) {
2429 if (old_execute_data->symbol_table == symbol_table) {
2430 zend_attach_symbol_table(old_execute_data);
2431 }
2432 break;
2433 }
2434 old_execute_data = old_execute_data->prev_execute_data;
2435 }
2436 EG(current_execute_data) = EX(prev_execute_data);
2437 }
2438
2439 ZEND_VM_RETURN();
2440 }
2441 }
2442
2443 ZEND_VM_HANDLER(42, ZEND_JMP, ANY, ANY)
2444 {
2445 USE_OPLINE
2446
2447 ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op1));
2448 ZEND_VM_CONTINUE();
2449 }
2450
2451 ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMPVAR|CV, ANY)
2452 {
2453 USE_OPLINE
2454 zend_free_op free_op1;
2455 zval *val;
2456
2457 val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
2458
2459 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
2460 ZEND_VM_SET_NEXT_OPCODE(opline + 1);
2461 ZEND_VM_CONTINUE();
2462 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
2463 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
2464 SAVE_OPLINE();
2465 GET_OP1_UNDEF_CV(val, BP_VAR_R);
2466 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
2467 } else {
2468 ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
2469 ZEND_VM_CONTINUE();
2470 }
2471 }
2472
2473 SAVE_OPLINE();
2474 if (i_zend_is_true(val)) {
2475 opline++;
2476 } else {
2477 opline = OP_JMP_ADDR(opline, opline->op2);
2478 }
2479 FREE_OP1();
2480 if (UNEXPECTED(EG(exception) != NULL)) {
2481 HANDLE_EXCEPTION();
2482 }
2483 ZEND_VM_JMP(opline);
2484 }
2485
2486 ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMPVAR|CV, ANY)
2487 {
2488 USE_OPLINE
2489 zend_free_op free_op1;
2490 zval *val;
2491
2492 val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
2493
2494 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
2495 ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
2496 ZEND_VM_CONTINUE();
2497 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
2498 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
2499 SAVE_OPLINE();
2500 GET_OP1_UNDEF_CV(val, BP_VAR_R);
2501 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2502 } else {
2503 ZEND_VM_NEXT_OPCODE();
2504 }
2505 }
2506
2507 SAVE_OPLINE();
2508 if (i_zend_is_true(val)) {
2509 opline = OP_JMP_ADDR(opline, opline->op2);
2510 } else {
2511 opline++;
2512 }
2513 FREE_OP1();
2514 if (UNEXPECTED(EG(exception) != NULL)) {
2515 HANDLE_EXCEPTION();
2516 }
2517 ZEND_VM_JMP(opline);
2518 }
2519
2520 ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMPVAR|CV, ANY)
2521 {
2522 USE_OPLINE
2523 zend_free_op free_op1;
2524 zval *val;
2525
2526 val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
2527
2528 if (EXPECTED(Z_TYPE_INFO_P(val) == IS_TRUE)) {
2529 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
2530 ZEND_VM_CONTINUE();
2531 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
2532 if (OP1_TYPE == IS_CV) {
2533 if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
2534 SAVE_OPLINE();
2535 GET_OP1_UNDEF_CV(val, BP_VAR_R);
2536 }
2537 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
2538 } else {
2539 ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
2540 ZEND_VM_CONTINUE();
2541 }
2542 }
2543
2544 SAVE_OPLINE();
2545 if (i_zend_is_true(val)) {
2546 opline = ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value);
2547 } else {
2548 opline = OP_JMP_ADDR(opline, opline->op2);
2549 }
2550 FREE_OP1();
2551 if (UNEXPECTED(EG(exception) != NULL)) {
2552 HANDLE_EXCEPTION();
2553 }
2554 ZEND_VM_JMP(opline);
2555 }
2556
2557 ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMPVAR|CV, ANY)
2558 {
2559 USE_OPLINE
2560 zend_free_op free_op1;
2561 zval *val;
2562 int ret;
2563
2564 val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
2565
2566 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
2567 ZVAL_TRUE(EX_VAR(opline->result.var));
2568 ZEND_VM_SET_NEXT_OPCODE(opline + 1);
2569 ZEND_VM_CONTINUE();
2570 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
2571 ZVAL_FALSE(EX_VAR(opline->result.var));
2572 if (OP1_TYPE == IS_CV) {
2573 if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
2574 SAVE_OPLINE();
2575 GET_OP1_UNDEF_CV(val, BP_VAR_R);
2576 }
2577 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
2578 } else {
2579 ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
2580 ZEND_VM_CONTINUE();
2581 }
2582 }
2583
2584 SAVE_OPLINE();
2585 ret = i_zend_is_true(val);
2586 FREE_OP1();
2587 if (ret) {
2588 ZVAL_TRUE(EX_VAR(opline->result.var));
2589 opline++;
2590 } else {
2591 ZVAL_FALSE(EX_VAR(opline->result.var));
2592 opline = OP_JMP_ADDR(opline, opline->op2);
2593 }
2594 if (UNEXPECTED(EG(exception) != NULL)) {
2595 HANDLE_EXCEPTION();
2596 }
2597 ZEND_VM_JMP(opline);
2598 }
2599
2600 ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMPVAR|CV, ANY)
2601 {
2602 USE_OPLINE
2603 zend_free_op free_op1;
2604 zval *val;
2605 int ret;
2606
2607 val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
2608
2609 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
2610 ZVAL_TRUE(EX_VAR(opline->result.var));
2611 ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
2612 ZEND_VM_CONTINUE();
2613 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
2614 ZVAL_FALSE(EX_VAR(opline->result.var));
2615 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
2616 SAVE_OPLINE();
2617 GET_OP1_UNDEF_CV(val, BP_VAR_R);
2618 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2619 } else {
2620 ZEND_VM_NEXT_OPCODE();
2621 }
2622 }
2623
2624 SAVE_OPLINE();
2625 ret = i_zend_is_true(val);
2626 FREE_OP1();
2627 if (ret) {
2628 ZVAL_TRUE(EX_VAR(opline->result.var));
2629 opline = OP_JMP_ADDR(opline, opline->op2);
2630 } else {
2631 ZVAL_FALSE(EX_VAR(opline->result.var));
2632 opline++;
2633 }
2634 if (UNEXPECTED(EG(exception) != NULL)) {
2635 HANDLE_EXCEPTION();
2636 }
2637 ZEND_VM_JMP(opline);
2638 }
2639
2640 ZEND_VM_HANDLER(70, ZEND_FREE, TMPVAR, ANY)
2641 {
2642 USE_OPLINE
2643
2644 SAVE_OPLINE();
2645 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
2646 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2647 }
2648
2649 ZEND_VM_HANDLER(127, ZEND_FE_FREE, TMPVAR, ANY)
2650 {
2651 zval *var;
2652 USE_OPLINE
2653
2654 SAVE_OPLINE();
2655 var = EX_VAR(opline->op1.var);
2656 if (Z_TYPE_P(var) != IS_ARRAY && Z_FE_ITER_P(var) != (uint32_t)-1) {
2657 zend_hash_iterator_del(Z_FE_ITER_P(var));
2658 }
2659 zval_ptr_dtor_nogc(var);
2660 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2661 }
2662
2663 ZEND_VM_HANDLER(53, ZEND_FAST_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
2664 {
2665 USE_OPLINE
2666 zend_free_op free_op1, free_op2;
2667 zval *op1, *op2;
2668 zend_string *op1_str, *op2_str, *str;
2669
2670 SAVE_OPLINE();
2671 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
2672 if (OP1_TYPE == IS_CONST) {
2673 op1_str = Z_STR_P(op1);
2674 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
2675 op1_str = zend_string_copy(Z_STR_P(op1));
2676 } else {
2677 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
2678 GET_OP1_UNDEF_CV(op1, BP_VAR_R);
2679 }
2680 op1_str = _zval_get_string_func(op1);
2681 }
2682 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
2683 if (OP2_TYPE == IS_CONST) {
2684 op2_str = Z_STR_P(op2);
2685 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
2686 op2_str = zend_string_copy(Z_STR_P(op2));
2687 } else {
2688 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
2689 GET_OP2_UNDEF_CV(op2, BP_VAR_R);
2690 }
2691 op2_str = _zval_get_string_func(op2);
2692 }
2693 do {
2694 if (OP1_TYPE != IS_CONST) {
2695 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
2696 if (OP2_TYPE == IS_CONST) {
2697 zend_string_addref(op2_str);
2698 }
2699 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
2700 zend_string_release(op1_str);
2701 break;
2702 }
2703 }
2704 if (OP2_TYPE != IS_CONST) {
2705 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
2706 if (OP1_TYPE == IS_CONST) {
2707 zend_string_addref(op1_str);
2708 }
2709 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
2710 zend_string_release(op2_str);
2711 break;
2712 }
2713 }
2714 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
2715 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
2716 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
2717 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
2718 if (OP1_TYPE != IS_CONST) {
2719 zend_string_release(op1_str);
2720 }
2721 if (OP2_TYPE != IS_CONST) {
2722 zend_string_release(op2_str);
2723 }
2724 } while (0);
2725 FREE_OP1();
2726 FREE_OP2();
2727 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2728 }
2729
2730 ZEND_VM_HANDLER(54, ZEND_ROPE_INIT, UNUSED, CONST|TMPVAR|CV)
2731 {
2732 USE_OPLINE
2733 zend_free_op free_op2;
2734 zend_string **rope;
2735 zval *var;
2736
2737
2738 rope = (zend_string**)EX_VAR(opline->result.var);
2739 if (OP2_TYPE == IS_CONST) {
2740 var = GET_OP2_ZVAL_PTR(BP_VAR_R);
2741 rope[0] = zend_string_copy(Z_STR_P(var));
2742 } else {
2743 var = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
2744 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
2745 if (OP2_TYPE == IS_CV) {
2746 rope[0] = zend_string_copy(Z_STR_P(var));
2747 } else {
2748 rope[0] = Z_STR_P(var);
2749 }
2750 } else {
2751 SAVE_OPLINE();
2752 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
2753 GET_OP2_UNDEF_CV(var, BP_VAR_R);
2754 }
2755 rope[0] = _zval_get_string_func(var);
2756 FREE_OP2();
2757 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2758 }
2759 }
2760 ZEND_VM_NEXT_OPCODE();
2761 }
2762
2763 ZEND_VM_HANDLER(55, ZEND_ROPE_ADD, TMP, CONST|TMPVAR|CV)
2764 {
2765 USE_OPLINE
2766 zend_free_op free_op2;
2767 zend_string **rope;
2768 zval *var;
2769
2770
2771 rope = (zend_string**)EX_VAR(opline->op1.var);
2772 if (OP2_TYPE == IS_CONST) {
2773 var = GET_OP2_ZVAL_PTR(BP_VAR_R);
2774 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
2775 } else {
2776 var = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
2777 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
2778 if (OP2_TYPE == IS_CV) {
2779 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
2780 } else {
2781 rope[opline->extended_value] = Z_STR_P(var);
2782 }
2783 } else {
2784 SAVE_OPLINE();
2785 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
2786 GET_OP2_UNDEF_CV(var, BP_VAR_R);
2787 }
2788 rope[opline->extended_value] = _zval_get_string_func(var);
2789 FREE_OP2();
2790 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2791 }
2792 }
2793 ZEND_VM_NEXT_OPCODE();
2794 }
2795
2796 ZEND_VM_HANDLER(56, ZEND_ROPE_END, TMP, CONST|TMPVAR|CV)
2797 {
2798 USE_OPLINE
2799 zend_free_op free_op2;
2800 zend_string **rope;
2801 zval *var, *ret;
2802 uint32_t i;
2803 size_t len = 0;
2804 char *target;
2805
2806 rope = (zend_string**)EX_VAR(opline->op1.var);
2807 if (OP2_TYPE == IS_CONST) {
2808 var = GET_OP2_ZVAL_PTR(BP_VAR_R);
2809 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
2810 } else {
2811 var = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
2812 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
2813 if (OP2_TYPE == IS_CV) {
2814 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
2815 } else {
2816 rope[opline->extended_value] = Z_STR_P(var);
2817 }
2818 } else {
2819 SAVE_OPLINE();
2820 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
2821 GET_OP2_UNDEF_CV(var, BP_VAR_R);
2822 }
2823 rope[opline->extended_value] = _zval_get_string_func(var);
2824 FREE_OP2();
2825 if (UNEXPECTED(EG(exception))) {
2826 for (i = 0; i <= opline->extended_value; i++) {
2827 zend_string_release(rope[i]);
2828 }
2829 HANDLE_EXCEPTION();
2830 }
2831 }
2832 }
2833 for (i = 0; i <= opline->extended_value; i++) {
2834 len += ZSTR_LEN(rope[i]);
2835 }
2836 ret = EX_VAR(opline->result.var);
2837 ZVAL_STR(ret, zend_string_alloc(len, 0));
2838 target = Z_STRVAL_P(ret);
2839 for (i = 0; i <= opline->extended_value; i++) {
2840 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
2841 target += ZSTR_LEN(rope[i]);
2842 zend_string_release(rope[i]);
2843 }
2844 *target = '\0';
2845
2846 ZEND_VM_NEXT_OPCODE();
2847 }
2848
2849 ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMPVAR|UNUSED|CV)
2850 {
2851 USE_OPLINE
2852
2853 SAVE_OPLINE();
2854 if (OP2_TYPE == IS_UNUSED) {
2855 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value);
2856 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2857 } else {
2858 zend_free_op free_op2;
2859 zval *class_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
2860
2861 ZEND_VM_C_LABEL(try_class_name):
2862 if (OP2_TYPE == IS_CONST) {
2863 zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
2864
2865 if (UNEXPECTED(ce == NULL)) {
2866 ce = zend_fetch_class_by_name(Z_STR_P(class_name), EX_CONSTANT(opline->op2) + 1, opline->extended_value);
2867 CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
2868 }
2869 Z_CE_P(EX_VAR(opline->result.var)) = ce;
2870 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
2871 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
2872 } else if (Z_TYPE_P(class_name) == IS_STRING) {
2873 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value);
2874 } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
2875 class_name = Z_REFVAL_P(class_name);
2876 ZEND_VM_C_GOTO(try_class_name);
2877 } else {
2878 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
2879 GET_OP2_UNDEF_CV(class_name, BP_VAR_R);
2880 if (UNEXPECTED(EG(exception) != NULL)) {
2881 HANDLE_EXCEPTION();
2882 }
2883 }
2884 zend_throw_error(NULL, "Class name must be a valid object or a string");
2885 }
2886
2887 FREE_OP2();
2888 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2889 }
2890 }
2891
2892 ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|CV, CONST|TMPVAR|CV)
2893 {
2894 USE_OPLINE
2895 zval *function_name;
2896 zend_free_op free_op1, free_op2;
2897 zval *object;
2898 zend_function *fbc;
2899 zend_class_entry *called_scope;
2900 zend_object *obj;
2901 zend_execute_data *call;
2902 uint32_t call_info;
2903
2904 SAVE_OPLINE();
2905
2906 function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
2907
2908 if (OP2_TYPE != IS_CONST &&
2909 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
2910 do {
2911 if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
2912 function_name = Z_REFVAL_P(function_name);
2913 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
2914 break;
2915 }
2916 } else if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
2917 GET_OP2_UNDEF_CV(function_name, BP_VAR_R);
2918 if (UNEXPECTED(EG(exception) != NULL)) {
2919 HANDLE_EXCEPTION();
2920 }
2921 }
2922 zend_throw_error(NULL, "Method name must be a string");
2923 FREE_OP2();
2924 FREE_UNFETCHED_OP1();
2925 HANDLE_EXCEPTION();
2926 } while (0);
2927 }
2928
2929 object = GET_OP1_OBJ_ZVAL_PTR_UNDEF(BP_VAR_R);
2930
2931 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(object) == NULL)) {
2932 zend_throw_error(NULL, "Using $this when not in object context");
2933 FREE_OP2();
2934 HANDLE_EXCEPTION();
2935 }
2936
2937 if (OP1_TYPE != IS_UNUSED) {
2938 do {
2939 if (OP1_TYPE == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
2940 if ((OP1_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
2941 object = Z_REFVAL_P(object);
2942 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
2943 break;
2944 }
2945 }
2946 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
2947 object = GET_OP1_UNDEF_CV(object, BP_VAR_R);
2948 if (UNEXPECTED(EG(exception) != NULL)) {
2949 FREE_OP2();
2950 HANDLE_EXCEPTION();
2951 }
2952 }
2953 zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
2954 FREE_OP2();
2955 FREE_OP1();
2956 HANDLE_EXCEPTION();
2957 }
2958 } while (0);
2959 }
2960
2961 obj = Z_OBJ_P(object);
2962 called_scope = obj->ce;
2963
2964 if (OP2_TYPE != IS_CONST ||
2965 UNEXPECTED((fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope)) == NULL)) {
2966 zend_object *orig_obj = obj;
2967
2968 if (UNEXPECTED(obj->handlers->get_method == NULL)) {
2969 zend_throw_error(NULL, "Object does not support method calls");
2970 FREE_OP2();
2971 FREE_OP1();
2972 HANDLE_EXCEPTION();
2973 }
2974
2975
2976 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL));
2977 if (UNEXPECTED(fbc == NULL)) {
2978 if (EXPECTED(!EG(exception))) {
2979 zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name));
2980 }
2981 FREE_OP2();
2982 FREE_OP1();
2983 HANDLE_EXCEPTION();
2984 }
2985 if (OP2_TYPE == IS_CONST &&
2986 EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
2987 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
2988 EXPECTED(obj == orig_obj)) {
2989 CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
2990 }
2991 }
2992
2993 call_info = ZEND_CALL_NESTED_FUNCTION;
2994 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
2995 obj = NULL;
2996 } else if (OP1_TYPE & (IS_VAR|IS_TMP_VAR|IS_CV)) {
2997
2998 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
2999 GC_REFCOUNT(obj)++;
3000 }
3001
3002 call = zend_vm_stack_push_call_frame(call_info,
3003 fbc, opline->extended_value, called_scope, obj);
3004 call->prev_execute_data = EX(call);
3005 EX(call) = call;
3006
3007 FREE_OP2();
3008 FREE_OP1();
3009
3010 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3011 }
3012
3013 ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMPVAR|UNUSED|CV)
3014 {
3015 USE_OPLINE
3016 zval *function_name;
3017 zend_class_entry *ce;
3018 zend_object *object;
3019 zend_function *fbc;
3020 zend_execute_data *call;
3021
3022 SAVE_OPLINE();
3023
3024 if (OP1_TYPE == IS_CONST) {
3025
3026 ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
3027 if (UNEXPECTED(ce == NULL)) {
3028 ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
3029 if (UNEXPECTED(ce == NULL)) {
3030 if (UNEXPECTED(EG(exception) != NULL)) {
3031 HANDLE_EXCEPTION();
3032 }
3033 zend_throw_error(NULL, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1)));
3034 HANDLE_EXCEPTION();
3035 }
3036 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce);
3037 }
3038 } else {
3039 ce = Z_CE_P(EX_VAR(opline->op1.var));
3040 }
3041
3042 if (OP1_TYPE == IS_CONST &&
3043 OP2_TYPE == IS_CONST &&
3044 EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) != NULL)) {
3045
3046 } else if (OP1_TYPE != IS_CONST &&
3047 OP2_TYPE == IS_CONST &&
3048 (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) {
3049
3050 } else if (OP2_TYPE != IS_UNUSED) {
3051 zend_free_op free_op2;
3052
3053 function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
3054 if (OP2_TYPE != IS_CONST) {
3055 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
3056 do {
3057 if (OP2_TYPE & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
3058 function_name = Z_REFVAL_P(function_name);
3059 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
3060 break;
3061 }
3062 } else if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
3063 GET_OP2_UNDEF_CV(function_name, BP_VAR_R);
3064 if (UNEXPECTED(EG(exception) != NULL)) {
3065 HANDLE_EXCEPTION();
3066 }
3067 }
3068 zend_throw_error(NULL, "Function name must be a string");
3069 FREE_OP2();
3070 HANDLE_EXCEPTION();
3071 } while (0);
3072 }
3073 }
3074
3075 if (ce->get_static_method) {
3076 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
3077 } else {
3078 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL));
3079 }
3080 if (UNEXPECTED(fbc == NULL)) {
3081 if (EXPECTED(!EG(exception))) {
3082 zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name));
3083 }
3084 FREE_OP2();
3085 HANDLE_EXCEPTION();
3086 }
3087 if (OP2_TYPE == IS_CONST &&
3088 EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
3089 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
3090 if (OP1_TYPE == IS_CONST) {
3091 CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
3092 } else {
3093 CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
3094 }
3095 }
3096 if (OP2_TYPE != IS_CONST) {
3097 FREE_OP2();
3098 }
3099 } else {
3100 if (UNEXPECTED(ce->constructor == NULL)) {
3101 zend_throw_error(NULL, "Cannot call constructor");
3102 HANDLE_EXCEPTION();
3103 }
3104 if (Z_OBJ(EX(This)) && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
3105 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
3106 HANDLE_EXCEPTION();
3107 }
3108 fbc = ce->constructor;
3109 }
3110
3111 object = NULL;
3112 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
3113 if (Z_OBJ(EX(This)) && instanceof_function(Z_OBJCE(EX(This)), ce)) {
3114 object = Z_OBJ(EX(This));
3115 ce = object->ce;
3116 } else {
3117 if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3118
3119 zend_error(
3120 E_DEPRECATED,
3121 "Non-static method %s::%s() should not be called statically",
3122 ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name));
3123 if (UNEXPECTED(EG(exception) != NULL)) {
3124 HANDLE_EXCEPTION();
3125 }
3126 } else {
3127
3128
3129 zend_throw_error(
3130 zend_ce_error,
3131 "Non-static method %s::%s() cannot be called statically",
3132 ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name));
3133 HANDLE_EXCEPTION();
3134 }
3135 }
3136 }
3137
3138 if (OP1_TYPE != IS_CONST) {
3139
3140 if (((opline-1)->extended_value & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
3141 ((opline-1)->extended_value & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
3142 ce = EX(called_scope);
3143 }
3144 }
3145
3146 call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
3147 fbc, opline->extended_value, ce, object);
3148 call->prev_execute_data = EX(call);
3149 EX(call) = call;
3150
3151 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3152 }
3153
3154 ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST)
3155 {
3156 USE_OPLINE
3157 zend_function *fbc;
3158 zval *function_name, *func;
3159 zend_execute_data *call;
3160
3161 fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
3162 if (UNEXPECTED(fbc == NULL)) {
3163 function_name = (zval*)(EX_CONSTANT(opline->op2)+1);
3164 func = zend_hash_find(EG(function_table), Z_STR_P(function_name));
3165 if (UNEXPECTED(func == NULL)) {
3166 SAVE_OPLINE();
3167 zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(EX_CONSTANT(opline->op2)));
3168 HANDLE_EXCEPTION();
3169 }
3170 fbc = Z_FUNC_P(func);
3171 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc);
3172 }
3173 call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
3174 fbc, opline->extended_value, NULL, NULL);
3175 call->prev_execute_data = EX(call);
3176 EX(call) = call;
3177
3178 ZEND_VM_NEXT_OPCODE();
3179 }
3180
3181 ZEND_VM_HANDLER(128, ZEND_INIT_DYNAMIC_CALL, ANY, CONST|TMPVAR|CV)
3182 {
3183 USE_OPLINE
3184 zend_function *fbc;
3185 zval *function_name, *func;
3186 zend_string *lcname;
3187 zend_free_op free_op2;
3188 zend_class_entry *called_scope;
3189 zend_object *object;
3190 zend_execute_data *call;
3191 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION;
3192
3193 SAVE_OPLINE();
3194 function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
3195
3196 ZEND_VM_C_LABEL(try_function_name):
3197 if (OP2_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
3198 const char *colon;
3199
3200 if ((colon = zend_memrchr(Z_STRVAL_P(function_name), ':', Z_STRLEN_P(function_name))) != NULL &&
3201 colon > Z_STRVAL_P(function_name) &&
3202 *(colon-1) == ':'
3203 ) {
3204 zend_string *mname;
3205 size_t cname_length = colon - Z_STRVAL_P(function_name) - 1;
3206 size_t mname_length = Z_STRLEN_P(function_name) - cname_length - (sizeof("::") - 1);
3207
3208 lcname = zend_string_init(Z_STRVAL_P(function_name), cname_length, 0);
3209
3210 object = NULL;
3211 called_scope = zend_fetch_class_by_name(lcname, NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
3212 if (UNEXPECTED(called_scope == NULL)) {
3213 zend_string_release(lcname);
3214 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3215 }
3216
3217 mname = zend_string_init(Z_STRVAL_P(function_name) + (cname_length + sizeof("::") - 1), mname_length, 0);
3218
3219 if (called_scope->get_static_method) {
3220 fbc = called_scope->get_static_method(called_scope, mname);
3221 } else {
3222 fbc = zend_std_get_static_method(called_scope, mname, NULL);
3223 }
3224 if (UNEXPECTED(fbc == NULL)) {
3225 if (EXPECTED(!EG(exception))) {
3226 zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), ZSTR_VAL(mname));
3227 }
3228 zend_string_release(lcname);
3229 zend_string_release(mname);
3230 FREE_OP2();
3231 HANDLE_EXCEPTION();
3232 }
3233
3234 zend_string_release(lcname);
3235 zend_string_release(mname);
3236
3237 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
3238 if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3239 zend_error(E_DEPRECATED,
3240 "Non-static method %s::%s() should not be called statically",
3241 ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name));
3242 if (UNEXPECTED(EG(exception) != NULL)) {
3243 HANDLE_EXCEPTION();
3244 }
3245 } else {
3246 zend_throw_error(
3247 zend_ce_error,
3248 "Non-static method %s::%s() cannot be called statically",
3249 ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name));
3250 FREE_OP2();
3251 HANDLE_EXCEPTION();
3252 }
3253 }
3254 } else {
3255 if (Z_STRVAL_P(function_name)[0] == '\\') {
3256 lcname = zend_string_alloc(Z_STRLEN_P(function_name) - 1, 0);
3257 zend_str_tolower_copy(ZSTR_VAL(lcname), Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1);
3258 } else {
3259 lcname = zend_string_tolower(Z_STR_P(function_name));
3260 }
3261 if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
3262 zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name));
3263 zend_string_release(lcname);
3264 FREE_OP2();
3265 HANDLE_EXCEPTION();
3266 }
3267 zend_string_release(lcname);
3268
3269 fbc = Z_FUNC_P(func);
3270 called_scope = NULL;
3271 object = NULL;
3272 }
3273 FREE_OP2();
3274 } else if (OP2_TYPE != IS_CONST &&
3275 EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
3276 Z_OBJ_HANDLER_P(function_name, get_closure) &&
3277 Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object) == SUCCESS) {
3278 if (fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
3279
3280 ZEND_ASSERT(GC_TYPE((zend_object*)fbc->common.prototype) == IS_OBJECT);
3281 GC_REFCOUNT((zend_object*)fbc->common.prototype)++;
3282 call_info |= ZEND_CALL_CLOSURE;
3283 } else if (object) {
3284 call_info |= ZEND_CALL_RELEASE_THIS;
3285 GC_REFCOUNT(object)++;
3286 }
3287 FREE_OP2();
3288 } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
3289 zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
3290 zval *obj;
3291 zval *method;
3292 obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0);
3293 method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1);
3294
3295 if (!obj || !method) {
3296 zend_throw_error(NULL, "Array callback has to contain indices 0 and 1");
3297 FREE_OP2();
3298 HANDLE_EXCEPTION();
3299 }
3300
3301 ZVAL_DEREF(obj);
3302 if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) {
3303 zend_throw_error(NULL, "First array member is not a valid class name or object");
3304 FREE_OP2();
3305 HANDLE_EXCEPTION();
3306 }
3307
3308 ZVAL_DEREF(method);
3309 if (Z_TYPE_P(method) != IS_STRING) {
3310 zend_throw_error(NULL, "Second array member is not a valid method");
3311 FREE_OP2();
3312 HANDLE_EXCEPTION();
3313 }
3314
3315 if (Z_TYPE_P(obj) == IS_STRING) {
3316 object = NULL;
3317 called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
3318 if (UNEXPECTED(called_scope == NULL)) {
3319 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3320 }
3321
3322 if (called_scope->get_static_method) {
3323 fbc = called_scope->get_static_method(called_scope, Z_STR_P(method));
3324 } else {
3325 fbc = zend_std_get_static_method(called_scope, Z_STR_P(method), NULL);
3326 }
3327 if (UNEXPECTED(fbc == NULL)) {
3328 if (EXPECTED(!EG(exception))) {
3329 zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), Z_STRVAL_P(method));
3330 }
3331 FREE_OP2();
3332 HANDLE_EXCEPTION();
3333 }
3334 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
3335 if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3336 zend_error(E_DEPRECATED,
3337 "Non-static method %s::%s() should not be called statically",
3338 ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name));
3339 if (UNEXPECTED(EG(exception) != NULL)) {
3340 HANDLE_EXCEPTION();
3341 }
3342 } else {
3343 zend_throw_error(
3344 zend_ce_error,
3345 "Non-static method %s::%s() cannot be called statically",
3346 ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name));
3347 FREE_OP2();
3348 HANDLE_EXCEPTION();
3349 }
3350 }
3351 } else {
3352 called_scope = Z_OBJCE_P(obj);
3353 object = Z_OBJ_P(obj);
3354
3355 fbc = Z_OBJ_HT_P(obj)->get_method(&object, Z_STR_P(method), NULL);
3356 if (UNEXPECTED(fbc == NULL)) {
3357 if (EXPECTED(!EG(exception))) {
3358 zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(object->ce->name), Z_STRVAL_P(method));
3359 }
3360 FREE_OP2();
3361 HANDLE_EXCEPTION();
3362 }
3363
3364 if ((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
3365 object = NULL;
3366 } else {
3367 call_info |= ZEND_CALL_RELEASE_THIS;
3368 GC_REFCOUNT(object)++;
3369 }
3370 }
3371 FREE_OP2();
3372 } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(function_name) == IS_REFERENCE) {
3373 function_name = Z_REFVAL_P(function_name);
3374 ZEND_VM_C_GOTO(try_function_name);
3375 } else {
3376 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
3377 GET_OP2_UNDEF_CV(function_name, BP_VAR_R);
3378 if (UNEXPECTED(EG(exception) != NULL)) {
3379 HANDLE_EXCEPTION();
3380 }
3381 }
3382 zend_throw_error(NULL, "Function name must be a string");
3383 FREE_OP2();
3384 HANDLE_EXCEPTION();
3385 }
3386 call = zend_vm_stack_push_call_frame(call_info,
3387 fbc, opline->extended_value, called_scope, object);
3388 call->prev_execute_data = EX(call);
3389 EX(call) = call;
3390
3391 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3392 }
3393
3394 ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV)
3395 {
3396 USE_OPLINE
3397 zend_free_op free_op2;
3398 zval *function_name;
3399 zend_fcall_info_cache fcc;
3400 char *error = NULL;
3401 zend_function *func;
3402 zend_class_entry *called_scope;
3403 zend_object *object;
3404 zend_execute_data *call;
3405 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION;
3406
3407 SAVE_OPLINE();
3408 function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
3409 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
3410 func = fcc.function_handler;
3411 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
3412
3413 if (OP2_TYPE & (IS_VAR|IS_CV)) {
3414 ZVAL_DEREF(function_name);
3415 }
3416 ZEND_ASSERT(GC_TYPE((zend_object*)func->common.prototype) == IS_OBJECT);
3417 GC_REFCOUNT((zend_object*)func->common.prototype)++;
3418 call_info |= ZEND_CALL_CLOSURE;
3419 }
3420 called_scope = fcc.called_scope;
3421 object = fcc.object;
3422 if (object) {
3423 call_info |= ZEND_CALL_RELEASE_THIS;
3424 GC_REFCOUNT(object)++;
3425 }
3426 if (error) {
3427 efree(error);
3428
3429 zend_error(E_DEPRECATED,
3430 "Non-static method %s::%s() should not be called statically",
3431 ZSTR_VAL(func->common.scope->name), ZSTR_VAL(func->common.function_name));
3432 if (UNEXPECTED(EG(exception) != NULL)) {
3433 HANDLE_EXCEPTION();
3434 }
3435 }
3436 } else {
3437 zend_internal_type_error(EX_USES_STRICT_TYPES(), "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error);
3438 efree(error);
3439 func = (zend_function*)&zend_pass_function;
3440 called_scope = NULL;
3441 object = NULL;
3442 }
3443
3444 call = zend_vm_stack_push_call_frame(call_info,
3445 func, opline->extended_value, called_scope, object);
3446 call->prev_execute_data = EX(call);
3447 EX(call) = call;
3448
3449 FREE_OP2();
3450 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3451 }
3452
3453 ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST)
3454 {
3455 USE_OPLINE
3456 zval *func_name;
3457 zval *func;
3458 zend_function *fbc;
3459 zend_execute_data *call;
3460
3461 func_name = EX_CONSTANT(opline->op2) + 1;
3462 fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
3463 if (UNEXPECTED(fbc == NULL)) {
3464 func = zend_hash_find(EG(function_table), Z_STR_P(func_name));
3465 if (func == NULL) {
3466 func_name++;
3467 func = zend_hash_find(EG(function_table), Z_STR_P(func_name));
3468 if (UNEXPECTED(func == NULL)) {
3469 SAVE_OPLINE();
3470 zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(EX_CONSTANT(opline->op2)));
3471 HANDLE_EXCEPTION();
3472 }
3473 }
3474 fbc = Z_FUNC_P(func);
3475 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc);
3476 }
3477
3478 call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
3479 fbc, opline->extended_value, NULL, NULL);
3480 call->prev_execute_data = EX(call);
3481 EX(call) = call;
3482
3483 ZEND_VM_NEXT_OPCODE();
3484 }
3485
3486 ZEND_VM_HANDLER(61, ZEND_INIT_FCALL, ANY, CONST)
3487 {
3488 USE_OPLINE
3489 zend_free_op free_op2;
3490 zval *fname = GET_OP2_ZVAL_PTR(BP_VAR_R);
3491 zval *func;
3492 zend_function *fbc;
3493 zend_execute_data *call;
3494
3495 fbc = CACHED_PTR(Z_CACHE_SLOT_P(fname));
3496 if (UNEXPECTED(fbc == NULL)) {
3497 func = zend_hash_find(EG(function_table), Z_STR_P(fname));
3498 if (UNEXPECTED(func == NULL)) {
3499 SAVE_OPLINE();
3500 zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(fname));
3501 HANDLE_EXCEPTION();
3502 }
3503 fbc = Z_FUNC_P(func);
3504 CACHE_PTR(Z_CACHE_SLOT_P(fname), fbc);
3505 }
3506
3507 call = zend_vm_stack_push_call_frame_ex(
3508 opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
3509 fbc, opline->extended_value, NULL, NULL);
3510 call->prev_execute_data = EX(call);
3511 EX(call) = call;
3512
3513 ZEND_VM_NEXT_OPCODE();
3514 }
3515
3516 ZEND_VM_HANDLER(129, ZEND_DO_ICALL, ANY, ANY)
3517 {
3518 USE_OPLINE
3519 zend_execute_data *call = EX(call);
3520 zend_function *fbc = call->func;
3521 zval *ret;
3522
3523 SAVE_OPLINE();
3524 EX(call) = call->prev_execute_data;
3525
3526 call->prev_execute_data = execute_data;
3527 EG(current_execute_data) = call;
3528
3529 ret = EX_VAR(opline->result.var);
3530 ZVAL_NULL(ret);
3531 Z_VAR_FLAGS_P(ret) = 0;
3532
3533 fbc->internal_function.handler(call, ret);
3534
3535 #if ZEND_DEBUG
3536 ZEND_ASSERT(
3537 EG(exception) || !call->func ||
3538 !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3539 zend_verify_internal_return_type(call->func, EX_VAR(opline->result.var)));
3540 #endif
3541
3542 EG(current_execute_data) = call->prev_execute_data;
3543 zend_vm_stack_free_args(call);
3544 zend_vm_stack_free_call_frame(call);
3545
3546 if (!RETURN_VALUE_USED(opline)) {
3547 zval_ptr_dtor(EX_VAR(opline->result.var));
3548 }
3549
3550 if (UNEXPECTED(EG(exception) != NULL)) {
3551 zend_throw_exception_internal(NULL);
3552 if (RETURN_VALUE_USED(opline)) {
3553 zval_ptr_dtor(EX_VAR(opline->result.var));
3554 }
3555 HANDLE_EXCEPTION();
3556 }
3557
3558 ZEND_VM_INTERRUPT_CHECK();
3559 ZEND_VM_NEXT_OPCODE();
3560 }
3561
3562 ZEND_VM_HANDLER(130, ZEND_DO_UCALL, ANY, ANY)
3563 {
3564 USE_OPLINE
3565 zend_execute_data *call = EX(call);
3566 zend_function *fbc = call->func;
3567 zval *ret;
3568
3569 SAVE_OPLINE();
3570 EX(call) = call->prev_execute_data;
3571
3572 EG(scope) = NULL;
3573 ret = NULL;
3574 call->symbol_table = NULL;
3575 if (RETURN_VALUE_USED(opline)) {
3576 ret = EX_VAR(opline->result.var);
3577 ZVAL_NULL(ret);
3578 Z_VAR_FLAGS_P(ret) = 0;
3579 }
3580
3581 call->prev_execute_data = execute_data;
3582 i_init_func_execute_data(call, &fbc->op_array, ret, 0);
3583
3584 ZEND_VM_ENTER();
3585 }
3586
3587 ZEND_VM_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY)
3588 {
3589 USE_OPLINE
3590 zend_execute_data *call = EX(call);
3591 zend_function *fbc = call->func;
3592 zval *ret;
3593
3594 SAVE_OPLINE();
3595 EX(call) = call->prev_execute_data;
3596
3597 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
3598 EG(scope) = NULL;
3599 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_GENERATOR) != 0)) {
3600 if (EXPECTED(RETURN_VALUE_USED(opline))) {
3601 ret = EX_VAR(opline->result.var);
3602 zend_generator_create_zval(call, &fbc->op_array, ret);
3603 Z_VAR_FLAGS_P(ret) = 0;
3604 } else {
3605 zend_vm_stack_free_args(call);
3606 }
3607
3608 zend_vm_stack_free_call_frame(call);
3609 } else {
3610 ret = NULL;
3611 call->symbol_table = NULL;
3612 if (RETURN_VALUE_USED(opline)) {
3613 ret = EX_VAR(opline->result.var);
3614 ZVAL_NULL(ret);
3615 Z_VAR_FLAGS_P(ret) = 0;
3616 }
3617
3618 call->prev_execute_data = execute_data;
3619 i_init_func_execute_data(call, &fbc->op_array, ret, 0);
3620
3621 ZEND_VM_ENTER();
3622 }
3623 EG(scope) = EX(func)->op_array.scope;
3624 } else {
3625 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
3626
3627 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
3628 zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
3629 fbc->common.scope ? ZSTR_VAL(fbc->common.scope->name) : "",
3630 fbc->common.scope ? "::" : "",
3631 ZSTR_VAL(fbc->common.function_name));
3632 if (UNEXPECTED(EG(exception) != NULL)) {
3633 HANDLE_EXCEPTION();
3634 }
3635 }
3636
3637 call->prev_execute_data = execute_data;
3638 EG(current_execute_data) = call;
3639
3640 if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
3641 uint32_t i;
3642 uint32_t num_args = ZEND_CALL_NUM_ARGS(call);
3643 zval *p = ZEND_CALL_ARG(call, 1);
3644
3645 for (i = 0; i < num_args; ++i) {
3646 if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) {
3647 EG(current_execute_data) = call->prev_execute_data;
3648 zend_vm_stack_free_args(call);
3649 zend_vm_stack_free_call_frame(call);
3650 zend_throw_exception_internal(NULL);
3651 HANDLE_EXCEPTION();
3652 }
3653 p++;
3654 }
3655 }
3656
3657 ret = EX_VAR(opline->result.var);
3658 ZVAL_NULL(ret);
3659 Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
3660
3661 fbc->internal_function.handler(call, ret);
3662
3663 #if ZEND_DEBUG
3664 ZEND_ASSERT(
3665 EG(exception) || !call->func ||
3666 !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3667 zend_verify_internal_return_type(call->func, EX_VAR(opline->result.var)));
3668 #endif
3669
3670 EG(current_execute_data) = call->prev_execute_data;
3671 zend_vm_stack_free_args(call);
3672 zend_vm_stack_free_call_frame(call);
3673
3674 if (!RETURN_VALUE_USED(opline)) {
3675 zval_ptr_dtor(EX_VAR(opline->result.var));
3676 }
3677 }
3678
3679 if (UNEXPECTED(EG(exception) != NULL)) {
3680 zend_throw_exception_internal(NULL);
3681 if (RETURN_VALUE_USED(opline)) {
3682 zval_ptr_dtor(EX_VAR(opline->result.var));
3683 }
3684 HANDLE_EXCEPTION();
3685 }
3686 ZEND_VM_INTERRUPT_CHECK();
3687 ZEND_VM_NEXT_OPCODE();
3688 }
3689
3690 ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY)
3691 {
3692 USE_OPLINE
3693 zend_execute_data *call = EX(call);
3694 zend_function *fbc = call->func;
3695 zend_object *object;
3696 zval *ret;
3697
3698 SAVE_OPLINE();
3699 EX(call) = call->prev_execute_data;
3700 if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) {
3701 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) {
3702 zend_throw_error(NULL, "Cannot call abstract method %s::%s()", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name));
3703 HANDLE_EXCEPTION();
3704 }
3705 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
3706 zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
3707 fbc->common.scope ? ZSTR_VAL(fbc->common.scope->name) : "",
3708 fbc->common.scope ? "::" : "",
3709 ZSTR_VAL(fbc->common.function_name));
3710 if (UNEXPECTED(EG(exception) != NULL)) {
3711 HANDLE_EXCEPTION();
3712 }
3713 }
3714 }
3715
3716 LOAD_OPLINE();
3717
3718 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
3719 EG(scope) = fbc->common.scope;
3720 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_GENERATOR) != 0)) {
3721 if (EXPECTED(RETURN_VALUE_USED(opline))) {
3722 ret = EX_VAR(opline->result.var);
3723 zend_generator_create_zval(call, &fbc->op_array, ret);
3724 Z_VAR_FLAGS_P(ret) = 0;
3725 } else {
3726 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) {
3727 OBJ_RELEASE((zend_object*)fbc->op_array.prototype);
3728 }
3729 zend_vm_stack_free_args(call);
3730 }
3731 } else {
3732 ret = NULL;
3733 call->symbol_table = NULL;
3734 if (RETURN_VALUE_USED(opline)) {
3735 ret = EX_VAR(opline->result.var);
3736 ZVAL_NULL(ret);
3737 Z_VAR_FLAGS_P(ret) = 0;
3738 }
3739
3740 call->prev_execute_data = execute_data;
3741 i_init_func_execute_data(call, &fbc->op_array, ret, 1);
3742
3743 if (EXPECTED(zend_execute_ex == execute_ex)) {
3744 ZEND_VM_ENTER();
3745 } else {
3746 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
3747 zend_execute_ex(call);
3748 }
3749 }
3750 } else if (EXPECTED(fbc->type < ZEND_USER_FUNCTION)) {
3751 int should_change_scope = 0;
3752
3753 if (fbc->common.scope) {
3754 should_change_scope = 1;
3755 EG(scope) = fbc->common.scope;
3756 }
3757
3758 call->prev_execute_data = execute_data;
3759 EG(current_execute_data) = call;
3760
3761 if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
3762 uint32_t i;
3763 uint32_t num_args = ZEND_CALL_NUM_ARGS(call);
3764 zval *p = ZEND_CALL_ARG(call, 1);
3765
3766 for (i = 0; i < num_args; ++i) {
3767 if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) {
3768 EG(current_execute_data) = call->prev_execute_data;
3769 zend_vm_stack_free_args(call);
3770 if (RETURN_VALUE_USED(opline)) {
3771 ZVAL_UNDEF(EX_VAR(opline->result.var));
3772 }
3773 if (UNEXPECTED(should_change_scope)) {
3774 ZEND_VM_C_GOTO(fcall_end_change_scope);
3775 } else {
3776 ZEND_VM_C_GOTO(fcall_end);
3777 }
3778 }
3779 p++;
3780 }
3781 }
3782
3783 ret = EX_VAR(opline->result.var);
3784 ZVAL_NULL(ret);
3785 Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
3786
3787 if (!zend_execute_internal) {
3788
3789 fbc->internal_function.handler(call, ret);
3790 } else {
3791 zend_execute_internal(call, ret);
3792 }
3793
3794 #if ZEND_DEBUG
3795 ZEND_ASSERT(
3796 EG(exception) || !call->func ||
3797 !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3798 zend_verify_internal_return_type(call->func, EX_VAR(opline->result.var)));
3799 #endif
3800
3801 EG(current_execute_data) = call->prev_execute_data;
3802 zend_vm_stack_free_args(call);
3803
3804 if (!RETURN_VALUE_USED(opline)) {
3805 zval_ptr_dtor(EX_VAR(opline->result.var));
3806 }
3807
3808 if (UNEXPECTED(should_change_scope)) {
3809 ZEND_VM_C_GOTO(fcall_end_change_scope);
3810 } else {
3811 ZEND_VM_C_GOTO(fcall_end);
3812 }
3813 } else {
3814
3815 object = Z_OBJ(call->This);
3816 if (UNEXPECTED(object == NULL)) {
3817 zend_vm_stack_free_args(call);
3818 if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
3819 zend_string_release(fbc->common.function_name);
3820 }
3821 efree(fbc);
3822 zend_vm_stack_free_call_frame(call);
3823
3824 zend_throw_error(NULL, "Cannot call overloaded function for non-object");
3825 HANDLE_EXCEPTION();
3826 }
3827
3828 EG(scope) = fbc->common.scope;
3829
3830 ZVAL_NULL(EX_VAR(opline->result.var));
3831
3832 call->prev_execute_data = execute_data;
3833 EG(current_execute_data) = call;
3834 object->handlers->call_method(fbc->common.function_name, object, call, EX_VAR(opline->result.var));
3835 EG(current_execute_data) = call->prev_execute_data;
3836
3837 zend_vm_stack_free_args(call);
3838
3839 if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
3840 zend_string_release(fbc->common.function_name);
3841 }
3842 efree(fbc);
3843
3844 if (!RETURN_VALUE_USED(opline)) {
3845 zval_ptr_dtor(EX_VAR(opline->result.var));
3846 } else {
3847 Z_VAR_FLAGS_P(EX_VAR(opline->result.var)) = 0;
3848 }
3849 }
3850
3851 ZEND_VM_C_LABEL(fcall_end_change_scope):
3852 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
3853 object = Z_OBJ(call->This);
3854 #if 0
3855 if (UNEXPECTED(EG(exception) != NULL) && (opline->op1.num & ZEND_CALL_CTOR)) {
3856 if (!(opline->op1.num & ZEND_CALL_CTOR_RESULT_UNUSED)) {
3857 #else
3858 if (UNEXPECTED(EG(exception) != NULL) && (ZEND_CALL_INFO(call) & ZEND_CALL_CTOR)) {
3859 if (!(ZEND_CALL_INFO(call) & ZEND_CALL_CTOR_RESULT_UNUSED)) {
3860 #endif
3861 GC_REFCOUNT(object)--;
3862 }
3863 if (GC_REFCOUNT(object) == 1) {
3864 zend_object_store_ctor_failed(object);
3865 }
3866 }
3867 OBJ_RELEASE(object);
3868 }
3869 EG(scope) = EX(func)->op_array.scope;
3870
3871 ZEND_VM_C_LABEL(fcall_end):
3872 zend_vm_stack_free_call_frame(call);
3873 if (UNEXPECTED(EG(exception) != NULL)) {
3874 zend_throw_exception_internal(NULL);
3875 if (RETURN_VALUE_USED(opline)) {
3876 zval_ptr_dtor(EX_VAR(opline->result.var));
3877 }
3878 HANDLE_EXCEPTION();
3879 }
3880
3881 ZEND_VM_INTERRUPT_CHECK();
3882 ZEND_VM_NEXT_OPCODE();
3883 }
3884
3885 ZEND_VM_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED)
3886 {
3887 USE_OPLINE
3888
3889 SAVE_OPLINE();
3890 if (OP1_TYPE == IS_UNUSED) {
3891 zend_verify_missing_return_type(EX(func), CACHE_ADDR(opline->op2.num));
3892 } else {
3893
3894 #if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
3895 zval *retval_ref, *retval_ptr;
3896 zend_free_op free_op1;
3897 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
3898
3899 retval_ref = retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
3900
3901 if (OP1_TYPE == IS_CONST) {
3902 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
3903 retval_ref = retval_ptr = EX_VAR(opline->result.var);
3904 } else if (OP1_TYPE == IS_VAR) {
3905 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
3906 retval_ptr = Z_INDIRECT_P(retval_ptr);
3907 }
3908 ZVAL_DEREF(retval_ptr);
3909 } else if (OP1_TYPE == IS_CV) {
3910 ZVAL_DEREF(retval_ptr);
3911 }
3912
3913 if (UNEXPECTED(!ret_info->class_name
3914 && ret_info->type_hint != IS_CALLABLE
3915 && !ZEND_SAME_FAKE_TYPE(ret_info->type_hint, Z_TYPE_P(retval_ptr))
3916 && !(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)
3917 && retval_ref != retval_ptr)
3918 ) {
3919
3920 if (Z_REFCOUNT_P(retval_ref) == 1) {
3921 ZVAL_UNREF(retval_ref);
3922 } else {
3923 Z_DELREF_P(retval_ref);
3924 ZVAL_COPY(retval_ref, retval_ptr);
3925 }
3926 retval_ptr = retval_ref;
3927 }
3928 zend_verify_return_type(EX(func), retval_ptr, CACHE_ADDR(opline->op2.num));
3929
3930 if (UNEXPECTED(EG(exception) != NULL)) {
3931 if (OP1_TYPE == IS_CONST) {
3932 zval_ptr_dtor_nogc(retval_ptr);
3933 } else {
3934 FREE_OP1();
3935 }
3936 }
3937 #endif
3938 }
3939 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3940 }
3941
3942 ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
3943 {
3944 USE_OPLINE
3945 zval *retval_ptr;
3946 zend_free_op free_op1;
3947
3948 retval_ptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
3949 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
3950 SAVE_OPLINE();
3951 retval_ptr = GET_OP1_UNDEF_CV(retval_ptr, BP_VAR_R);
3952 if (EX(return_value)) {
3953 ZVAL_NULL(EX(return_value));
3954 }
3955 } else if (!EX(return_value)) {
3956 if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_TMP_VAR ) {
3957 if (Z_REFCOUNTED_P(free_op1) && !Z_DELREF_P(free_op1)) {
3958 SAVE_OPLINE();
3959 zval_dtor_func_for_ptr(Z_COUNTED_P(free_op1));
3960 }
3961 }
3962 } else {
3963 if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
3964 ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
3965 if (OP1_TYPE == IS_CONST) {
3966 if (UNEXPECTED(Z_OPT_COPYABLE_P(EX(return_value)))) {
3967 zval_copy_ctor_func(EX(return_value));
3968 }
3969 }
3970 } else if (OP1_TYPE == IS_CV) {
3971 ZVAL_DEREF(retval_ptr);
3972 ZVAL_COPY(EX(return_value), retval_ptr);
3973 } else {
3974 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
3975 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
3976
3977 retval_ptr = Z_REFVAL_P(retval_ptr);
3978 ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
3979 if (UNEXPECTED(--GC_REFCOUNT(ref) == 0)) {
3980 efree_size(ref, sizeof(zend_reference));
3981 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
3982 Z_ADDREF_P(retval_ptr);
3983 }
3984 } else {
3985 ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
3986 }
3987 }
3988 }
3989 ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
3990 }
3991
3992 ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
3993 {
3994 USE_OPLINE
3995 zval *retval_ptr;
3996 zend_free_op free_op1;
3997
3998 SAVE_OPLINE();
3999
4000 do {
4001 if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR ||
4002 (OP1_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4003
4004 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4005
4006 retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
4007 if (!EX(return_value)) {
4008 if (OP1_TYPE == IS_TMP_VAR) {
4009 FREE_OP1();
4010 }
4011 } else {
4012 ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
4013 Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF;
4014 if (OP1_TYPE != IS_TMP_VAR) {
4015 zval_opt_copy_ctor_no_imm(EX(return_value));
4016 }
4017 }
4018 break;
4019 }
4020
4021 retval_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
4022
4023 if (OP1_TYPE == IS_VAR && UNEXPECTED(retval_ptr == NULL)) {
4024 zend_throw_error(NULL, "Cannot return string offsets by reference");
4025 HANDLE_EXCEPTION();
4026 }
4027
4028 if (OP1_TYPE == IS_VAR) {
4029 if (retval_ptr == &EG(uninitialized_zval) ||
4030 (opline->extended_value == ZEND_RETURNS_FUNCTION &&
4031 !(Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF))) {
4032 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4033 if (EX(return_value)) {
4034 ZVAL_NEW_REF(EX(return_value), retval_ptr);
4035 Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF;
4036 if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
4037 }
4038 break;
4039 }
4040 }
4041
4042 if (EX(return_value)) {
4043 ZVAL_MAKE_REF(retval_ptr);
4044 Z_ADDREF_P(retval_ptr);
4045 ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
4046 Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF;
4047 }
4048 } while (0);
4049
4050 FREE_OP1_VAR_PTR();
4051 ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
4052 }
4053
4054 ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY)
4055 {
4056 USE_OPLINE
4057 zval *retval;
4058 zend_free_op free_op1;
4059
4060 zend_generator *generator = zend_get_running_generator(execute_data);
4061
4062 SAVE_OPLINE();
4063 retval = GET_OP1_ZVAL_PTR(BP_VAR_R);
4064
4065
4066 if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
4067 ZVAL_COPY_VALUE(&generator->retval, retval);
4068 if (OP1_TYPE == IS_CONST) {
4069 if (UNEXPECTED(Z_OPT_COPYABLE(generator->retval))) {
4070 zval_copy_ctor_func(&generator->retval);
4071 }
4072 }
4073 } else if (OP1_TYPE == IS_CV) {
4074 ZVAL_DEREF(retval);
4075 ZVAL_COPY(&generator->retval, retval);
4076 } else {
4077 if (UNEXPECTED(Z_ISREF_P(retval))) {
4078 zend_refcounted *ref = Z_COUNTED_P(retval);
4079
4080 retval = Z_REFVAL_P(retval);
4081 ZVAL_COPY_VALUE(&generator->retval, retval);
4082 if (UNEXPECTED(--GC_REFCOUNT(ref) == 0)) {
4083 efree_size(ref, sizeof(zend_reference));
4084 } else if (Z_OPT_REFCOUNTED_P(retval)) {
4085 Z_ADDREF_P(retval);
4086 }
4087 } else {
4088 ZVAL_COPY_VALUE(&generator->retval, retval);
4089 }
4090 }
4091
4092
4093 zend_generator_close(generator, 1);
4094
4095
4096 ZEND_VM_RETURN();
4097 }
4098
4099 ZEND_VM_HANDLER(108, ZEND_THROW, CONST|TMP|VAR|CV, ANY)
4100 {
4101 USE_OPLINE
4102 zval *value;
4103 zend_free_op free_op1;
4104
4105 SAVE_OPLINE();
4106 value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
4107
4108 do {
4109 if (OP1_TYPE == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
4110 if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
4111 value = Z_REFVAL_P(value);
4112 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
4113 break;
4114 }
4115 }
4116 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
4117 GET_OP1_UNDEF_CV(value, BP_VAR_R);
4118 if (UNEXPECTED(EG(exception) != NULL)) {
4119 HANDLE_EXCEPTION();
4120 }
4121 }
4122 zend_throw_error(NULL, "Can only throw objects");
4123 FREE_OP1();
4124 HANDLE_EXCEPTION();
4125 }
4126 } while (0);
4127
4128 zend_exception_save();
4129 if (OP1_TYPE != IS_TMP_VAR) {
4130 if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
4131 }
4132
4133 zend_throw_exception_object(value);
4134 zend_exception_restore();
4135 FREE_OP1_IF_VAR();
4136 HANDLE_EXCEPTION();
4137 }
4138
4139 ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV)
4140 {
4141 USE_OPLINE
4142 zend_class_entry *ce, *catch_ce;
4143 zend_object *exception;
4144
4145 SAVE_OPLINE();
4146
4147 zend_exception_restore();
4148 if (EG(exception) == NULL) {
4149 ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->extended_value]);
4150 ZEND_VM_CONTINUE();
4151 }
4152 catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
4153 if (UNEXPECTED(catch_ce == NULL)) {
4154 catch_ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
4155
4156 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), catch_ce);
4157 }
4158 ce = EG(exception)->ce;
4159
4160 #ifdef HAVE_DTRACE
4161 if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
4162 DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
4163 }
4164 #endif
4165
4166 if (ce != catch_ce) {
4167 if (!catch_ce || !instanceof_function(ce, catch_ce)) {
4168 if (opline->result.num) {
4169 zend_throw_exception_internal(NULL);
4170 HANDLE_EXCEPTION();
4171 }
4172 ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->extended_value]);
4173 ZEND_VM_CONTINUE();
4174 }
4175 }
4176
4177 exception = EG(exception);
4178 zval_ptr_dtor(EX_VAR(opline->op2.var));
4179 ZVAL_OBJ(EX_VAR(opline->op2.var), EG(exception));
4180 if (UNEXPECTED(EG(exception) != exception)) {
4181 GC_REFCOUNT(EG(exception))++;
4182 HANDLE_EXCEPTION();
4183 } else {
4184 EG(exception) = NULL;
4185 ZEND_VM_NEXT_OPCODE();
4186 }
4187 }
4188
4189 ZEND_VM_HANDLER(65, ZEND_SEND_VAL, CONST|TMP, ANY)
4190 {
4191 USE_OPLINE
4192 zval *value, *arg;
4193 zend_free_op free_op1;
4194
4195 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
4196 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4197 ZVAL_COPY_VALUE(arg, value);
4198 if (OP1_TYPE == IS_CONST) {
4199 if (UNEXPECTED(Z_OPT_COPYABLE_P(arg))) {
4200 zval_copy_ctor_func(arg);
4201 }
4202 }
4203 ZEND_VM_NEXT_OPCODE();
4204 }
4205
4206 ZEND_VM_HANDLER(116, ZEND_SEND_VAL_EX, CONST|TMP, ANY)
4207 {
4208 USE_OPLINE
4209 zval *value, *arg;
4210 zend_free_op free_op1;
4211 uint32_t arg_num = opline->op2.num;
4212
4213 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
4214 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
4215 ZEND_VM_C_GOTO(send_val_by_ref);
4216 }
4217 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
4218 ZEND_VM_C_LABEL(send_val_by_ref):
4219 SAVE_OPLINE();
4220 zend_throw_error(NULL, "Cannot pass parameter %d by reference", arg_num);
4221 FREE_UNFETCHED_OP1();
4222 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4223 ZVAL_UNDEF(arg);
4224 HANDLE_EXCEPTION();
4225 }
4226 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
4227 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4228 ZVAL_COPY_VALUE(arg, value);
4229 if (OP1_TYPE == IS_CONST) {
4230 if (UNEXPECTED(Z_OPT_COPYABLE_P(arg))) {
4231 zval_copy_ctor_func(arg);
4232 }
4233 }
4234 ZEND_VM_NEXT_OPCODE();
4235 }
4236
4237 ZEND_VM_HANDLER(117, ZEND_SEND_VAR, VAR|CV, ANY)
4238 {
4239 USE_OPLINE
4240 zval *varptr, *arg;
4241 zend_free_op free_op1;
4242
4243 varptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
4244 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
4245 SAVE_OPLINE();
4246 GET_OP1_UNDEF_CV(varptr, BP_VAR_R);
4247 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4248 ZVAL_NULL(arg);
4249 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4250 }
4251
4252 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4253
4254 if (OP1_TYPE == IS_CV) {
4255 ZVAL_OPT_DEREF(varptr);
4256 ZVAL_COPY(arg, varptr);
4257 } else {
4258 if (UNEXPECTED(Z_ISREF_P(varptr))) {
4259 zend_refcounted *ref = Z_COUNTED_P(varptr);
4260
4261 varptr = Z_REFVAL_P(varptr);
4262 ZVAL_COPY_VALUE(arg, varptr);
4263 if (UNEXPECTED(--GC_REFCOUNT(ref) == 0)) {
4264 efree_size(ref, sizeof(zend_reference));
4265 } else if (Z_OPT_REFCOUNTED_P(arg)) {
4266 Z_ADDREF_P(arg);
4267 }
4268 } else {
4269 ZVAL_COPY_VALUE(arg, varptr);
4270 }
4271 }
4272
4273 ZEND_VM_NEXT_OPCODE();
4274 }
4275
4276 ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR, ANY)
4277 {
4278 USE_OPLINE
4279 zend_free_op free_op1;
4280 zval *varptr, *arg;
4281
4282 if (!(opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND)) {
4283 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
4284 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_VAR);
4285 }
4286 }
4287
4288 varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
4289
4290 if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
4291 (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
4292 (Z_ISREF_P(varptr) || Z_TYPE_P(varptr) == IS_OBJECT)) {
4293
4294 ZVAL_MAKE_REF(varptr);
4295 } else {
4296 if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
4297 !(opline->extended_value & ZEND_ARG_SEND_SILENT) :
4298 !ARG_MAY_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
4299 SAVE_OPLINE();
4300 zend_error(E_NOTICE, "Only variables should be passed by reference");
4301 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4302 ZVAL_COPY_VALUE(arg, varptr);
4303 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4304 }
4305 }
4306
4307 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4308 ZVAL_COPY_VALUE(arg, varptr);
4309
4310 ZEND_VM_NEXT_OPCODE();
4311 }
4312
4313 ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, ANY)
4314 {
4315 USE_OPLINE
4316 zend_free_op free_op1;
4317 zval *varptr, *arg;
4318
4319 SAVE_OPLINE();
4320 varptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
4321
4322 if (OP1_TYPE == IS_VAR && UNEXPECTED(varptr == NULL)) {
4323 zend_throw_error(NULL, "Only variables can be passed by reference");
4324 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4325 ZVAL_UNDEF(arg);
4326 HANDLE_EXCEPTION();
4327 }
4328
4329 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4330 if (OP1_TYPE == IS_VAR && UNEXPECTED(varptr == &EG(error_zval))) {
4331 ZVAL_NEW_REF(arg, &EG(uninitialized_zval));
4332 ZEND_VM_NEXT_OPCODE();
4333 }
4334
4335 if (Z_ISREF_P(varptr)) {
4336 Z_ADDREF_P(varptr);
4337 ZVAL_COPY_VALUE(arg, varptr);
4338 } else {
4339 ZVAL_NEW_REF(arg, varptr);
4340 Z_ADDREF_P(arg);
4341 ZVAL_REF(varptr, Z_REF_P(arg));
4342 }
4343
4344 FREE_OP1_VAR_PTR();
4345 ZEND_VM_NEXT_OPCODE();
4346 }
4347
4348 ZEND_VM_HANDLER(66, ZEND_SEND_VAR_EX, VAR|CV, ANY)
4349 {
4350 USE_OPLINE
4351 zval *varptr, *arg;
4352 zend_free_op free_op1;
4353 uint32_t arg_num = opline->op2.num;
4354
4355 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
4356 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
4357 ZEND_VM_C_GOTO(send_var_by_ref);
4358 }
4359 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
4360 ZEND_VM_C_LABEL(send_var_by_ref):
4361 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_REF);
4362 }
4363
4364 varptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
4365 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
4366 SAVE_OPLINE();
4367 GET_OP1_UNDEF_CV(varptr, BP_VAR_R);
4368 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4369 ZVAL_NULL(arg);
4370 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4371 }
4372
4373 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
4374
4375 if (OP1_TYPE == IS_CV) {
4376 ZVAL_OPT_DEREF(varptr);
4377 ZVAL_COPY(arg, varptr);
4378 } else {
4379 if (UNEXPECTED(Z_ISREF_P(varptr))) {
4380 zend_refcounted *ref = Z_COUNTED_P(varptr);
4381
4382 varptr = Z_REFVAL_P(varptr);
4383 ZVAL_COPY_VALUE(arg, varptr);
4384 if (UNEXPECTED(--GC_REFCOUNT(ref) == 0)) {
4385 efree_size(ref, sizeof(zend_reference));
4386 } else if (Z_OPT_REFCOUNTED_P(arg)) {
4387 Z_ADDREF_P(arg);
4388 }
4389 } else {
4390 ZVAL_COPY_VALUE(arg, varptr);
4391 }
4392 }
4393
4394 ZEND_VM_NEXT_OPCODE();
4395 }
4396
4397 ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
4398 {
4399 USE_OPLINE
4400 zend_free_op free_op1;
4401 zval *args;
4402 int arg_num;
4403
4404 SAVE_OPLINE();
4405 args = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
4406 arg_num = ZEND_CALL_NUM_ARGS(EX(call)) + 1;
4407
4408 ZEND_VM_C_LABEL(send_again):
4409 if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
4410 HashTable *ht = Z_ARRVAL_P(args);
4411 zval *arg, *top;
4412 zend_string *name;
4413
4414 zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht));
4415
4416 if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_TMP_VAR && Z_IMMUTABLE_P(args)) {
4417 uint32_t i;
4418 int separate = 0;
4419
4420
4421 for (i = 0; i < zend_hash_num_elements(ht); i++) {
4422 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num + i)) {
4423 separate = 1;
4424 break;
4425 }
4426 }
4427 if (separate) {
4428 zval_copy_ctor(args);
4429 ht = Z_ARRVAL_P(args);
4430 }
4431 }
4432
4433 ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
4434 if (name) {
4435 zend_throw_error(NULL, "Cannot unpack array with string keys");
4436 FREE_OP1();
4437 HANDLE_EXCEPTION();
4438 }
4439
4440 top = ZEND_CALL_ARG(EX(call), arg_num);
4441 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
4442 if (!Z_IMMUTABLE_P(args)) {
4443 ZVAL_MAKE_REF(arg);
4444 Z_ADDREF_P(arg);
4445 ZVAL_REF(top, Z_REF_P(arg));
4446 } else {
4447 ZVAL_DUP(top, arg);
4448 }
4449 } else if (Z_ISREF_P(arg)) {
4450 ZVAL_COPY(top, Z_REFVAL_P(arg));
4451 } else {
4452 ZVAL_COPY(top, arg);
4453 }
4454
4455 ZEND_CALL_NUM_ARGS(EX(call))++;
4456 arg_num++;
4457 } ZEND_HASH_FOREACH_END();
4458
4459 } else if (EXPECTED(Z_TYPE_P(args) == IS_OBJECT)) {
4460 zend_class_entry *ce = Z_OBJCE_P(args);
4461 zend_object_iterator *iter;
4462
4463 if (!ce || !ce->get_iterator) {
4464 zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
4465 } else {
4466
4467 iter = ce->get_iterator(ce, args, 0);
4468 if (UNEXPECTED(!iter)) {
4469 FREE_OP1();
4470 if (!EG(exception)) {
4471 zend_throw_exception_ex(
4472 NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
4473 );
4474 }
4475 HANDLE_EXCEPTION();
4476 }
4477
4478 if (iter->funcs->rewind) {
4479 iter->funcs->rewind(iter);
4480 if (UNEXPECTED(EG(exception) != NULL)) {
4481 ZEND_VM_C_GOTO(unpack_iter_dtor);
4482 }
4483 }
4484
4485 for (; iter->funcs->valid(iter) == SUCCESS; ++arg_num) {
4486 zval *arg, *top;
4487
4488 if (UNEXPECTED(EG(exception) != NULL)) {
4489 ZEND_VM_C_GOTO(unpack_iter_dtor);
4490 }
4491
4492 arg = iter->funcs->get_current_data(iter);
4493 if (UNEXPECTED(EG(exception) != NULL)) {
4494 ZEND_VM_C_GOTO(unpack_iter_dtor);
4495 }
4496
4497 if (iter->funcs->get_current_key) {
4498 zval key;
4499 iter->funcs->get_current_key(iter, &key);
4500 if (UNEXPECTED(EG(exception) != NULL)) {
4501 ZEND_VM_C_GOTO(unpack_iter_dtor);
4502 }
4503
4504 if (Z_TYPE(key) == IS_STRING) {
4505 zend_throw_error(NULL,
4506 "Cannot unpack Traversable with string keys");
4507 zend_string_release(Z_STR(key));
4508 ZEND_VM_C_GOTO(unpack_iter_dtor);
4509 }
4510
4511 zval_dtor(&key);
4512 }
4513
4514 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
4515 zend_error(
4516 E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
4517 " by unpacking a Traversable, passing by-value instead", arg_num,
4518 EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
4519 EX(call)->func->common.scope ? "::" : "",
4520 ZSTR_VAL(EX(call)->func->common.function_name)
4521 );
4522 }
4523
4524 if (Z_ISREF_P(arg)) {
4525 ZVAL_DUP(arg, Z_REFVAL_P(arg));
4526 } else {
4527 if (Z_REFCOUNTED_P(arg)) Z_ADDREF_P(arg);
4528 }
4529
4530 zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1);
4531 top = ZEND_CALL_ARG(EX(call), arg_num);
4532 ZVAL_COPY_VALUE(top, arg);
4533 ZEND_CALL_NUM_ARGS(EX(call))++;
4534
4535 iter->funcs->move_forward(iter);
4536 if (UNEXPECTED(EG(exception) != NULL)) {
4537 ZEND_VM_C_GOTO(unpack_iter_dtor);
4538 }
4539 }
4540
4541 ZEND_VM_C_LABEL(unpack_iter_dtor):
4542 zend_iterator_dtor(iter);
4543 }
4544 } else if (EXPECTED(Z_ISREF_P(args))) {
4545 args = Z_REFVAL_P(args);
4546 ZEND_VM_C_GOTO(send_again);
4547 } else {
4548 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(args) == IS_UNDEF)) {
4549 GET_OP1_UNDEF_CV(args, BP_VAR_R);
4550 }
4551 zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
4552 }
4553
4554 FREE_OP1();
4555 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4556 }
4557
4558 ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY)
4559 {
4560 USE_OPLINE
4561 zend_free_op free_op1;
4562 zval *args;
4563 SAVE_OPLINE();
4564
4565 SAVE_OPLINE();
4566 args = GET_OP1_ZVAL_PTR(BP_VAR_R);
4567
4568 if (UNEXPECTED(Z_TYPE_P(args) != IS_ARRAY)) {
4569 if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(args)) {
4570 args = Z_REFVAL_P(args);
4571 if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
4572 ZEND_VM_C_GOTO(send_array);
4573 }
4574 }
4575 zend_internal_type_error(EX_USES_STRICT_TYPES(), "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
4576 if (ZEND_CALL_INFO(EX(call)) & ZEND_CALL_CLOSURE) {
4577 OBJ_RELEASE((zend_object*)EX(call)->func->common.prototype);
4578 }
4579 if (Z_OBJ(EX(call)->This)) {
4580 OBJ_RELEASE(Z_OBJ(EX(call)->This));
4581 }
4582 EX(call)->func = (zend_function*)&zend_pass_function;
4583 EX(call)->called_scope = NULL;
4584 Z_OBJ(EX(call)->This) = NULL;
4585 } else {
4586 uint32_t arg_num;
4587 HashTable *ht;
4588 zval *arg, *param;
4589
4590 ZEND_VM_C_LABEL(send_array):
4591 ht = Z_ARRVAL_P(args);
4592 zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht));
4593
4594 if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_TMP_VAR && Z_IMMUTABLE_P(args)) {
4595 int separate = 0;
4596
4597
4598 for (arg_num = 0; arg_num < zend_hash_num_elements(ht); arg_num++) {
4599 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num + 1)) {
4600 separate = 1;
4601 break;
4602 }
4603 }
4604 if (separate) {
4605 zval_copy_ctor(args);
4606 ht = Z_ARRVAL_P(args);
4607 }
4608 }
4609
4610 arg_num = 1;
4611 param = ZEND_CALL_ARG(EX(call), 1);
4612 ZEND_HASH_FOREACH_VAL(ht, arg) {
4613 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
4614 if (UNEXPECTED(!Z_ISREF_P(arg))) {
4615 if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
4616
4617 zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given",
4618 arg_num,
4619 EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
4620 EX(call)->func->common.scope ? "::" : "",
4621 ZSTR_VAL(EX(call)->func->common.function_name));
4622
4623 if (ZEND_CALL_INFO(EX(call)) & ZEND_CALL_CLOSURE) {
4624 OBJ_RELEASE((zend_object*)EX(call)->func->common.prototype);
4625 }
4626 if (Z_OBJ(EX(call)->This)) {
4627 OBJ_RELEASE(Z_OBJ(EX(call)->This));
4628 }
4629 EX(call)->func = (zend_function*)&zend_pass_function;
4630 EX(call)->called_scope = NULL;
4631 Z_OBJ(EX(call)->This) = NULL;
4632
4633 break;
4634 }
4635
4636 ZVAL_NEW_REF(arg, arg);
4637 }
4638 Z_ADDREF_P(arg);
4639 } else{
4640 if (Z_ISREF_P(arg) &&
4641 !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
4642
4643 arg = Z_REFVAL_P(arg);
4644 }
4645 if (Z_OPT_REFCOUNTED_P(arg)) {
4646 Z_ADDREF_P(arg);
4647 }
4648 }
4649 ZVAL_COPY_VALUE(param, arg);
4650 ZEND_CALL_NUM_ARGS(EX(call))++;
4651 arg_num++;
4652 param++;
4653 } ZEND_HASH_FOREACH_END();
4654 }
4655 FREE_OP1();
4656 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4657 }
4658
4659 ZEND_VM_HANDLER(120, ZEND_SEND_USER, VAR|CV, ANY)
4660 {
4661 USE_OPLINE
4662 zval *arg, *param;
4663 zend_free_op free_op1;
4664
4665 SAVE_OPLINE();
4666 arg = GET_OP1_ZVAL_PTR(BP_VAR_R);
4667 param = ZEND_CALL_VAR(EX(call), opline->result.var);
4668
4669 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
4670 if (UNEXPECTED(!Z_ISREF_P(arg))) {
4671
4672 if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
4673
4674 zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given",
4675 opline->op2.num,
4676 EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
4677 EX(call)->func->common.scope ? "::" : "",
4678 ZSTR_VAL(EX(call)->func->common.function_name));
4679
4680 if (ZEND_CALL_INFO(EX(call)) & ZEND_CALL_CLOSURE) {
4681 OBJ_RELEASE((zend_object*)EX(call)->func->common.prototype);
4682 }
4683 if (Z_OBJ(EX(call)->This)) {
4684 OBJ_RELEASE(Z_OBJ(EX(call)->This));
4685 }
4686 ZVAL_UNDEF(param);
4687 EX(call)->func = (zend_function*)&zend_pass_function;
4688 EX(call)->called_scope = NULL;
4689 Z_OBJ(EX(call)->This) = NULL;
4690
4691 FREE_OP1();
4692 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4693 }
4694
4695 ZVAL_NEW_REF(arg, arg);
4696 }
4697 Z_ADDREF_P(arg);
4698 } else {
4699 if (Z_ISREF_P(arg) &&
4700 !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
4701
4702 arg = Z_REFVAL_P(arg);
4703 }
4704 if (Z_OPT_REFCOUNTED_P(arg)) {
4705 Z_ADDREF_P(arg);
4706 }
4707 }
4708 ZVAL_COPY_VALUE(param, arg);
4709
4710 FREE_OP1();
4711 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4712 }
4713
4714 ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
4715 {
4716 USE_OPLINE
4717 uint32_t arg_num = opline->op1.num;
4718
4719 if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
4720 SAVE_OPLINE();
4721 zend_verify_missing_arg(execute_data, arg_num, CACHE_ADDR(opline->op2.num));
4722 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4723 } else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
4724 zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
4725
4726 SAVE_OPLINE();
4727 if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num)))) {
4728 HANDLE_EXCEPTION();
4729 }
4730 }
4731
4732 ZEND_VM_NEXT_OPCODE();
4733 }
4734
4735 ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST)
4736 {
4737 USE_OPLINE
4738 uint32_t arg_num;
4739 zval *param;
4740
4741 ZEND_VM_REPEATABLE_OPCODE
4742
4743 arg_num = opline->op1.num;
4744 param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
4745 if (arg_num > EX_NUM_ARGS()) {
4746 ZVAL_COPY_VALUE(param, EX_CONSTANT(opline->op2));
4747 if (Z_OPT_CONSTANT_P(param)) {
4748 SAVE_OPLINE();
4749 if (UNEXPECTED(zval_update_constant_ex(param, 0, NULL) != SUCCESS)) {
4750 ZVAL_UNDEF(param);
4751 HANDLE_EXCEPTION();
4752 }
4753 } else {
4754
4755 if (UNEXPECTED(Z_OPT_COPYABLE_P(param))) {
4756 zval_copy_ctor_func(param);
4757 }
4758 }
4759 }
4760
4761 if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
4762 zval *default_value = EX_CONSTANT(opline->op2);
4763
4764 SAVE_OPLINE();
4765 if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, default_value, CACHE_ADDR(Z_CACHE_SLOT_P(default_value))))) {
4766 HANDLE_EXCEPTION();
4767 }
4768 }
4769
4770 ZEND_VM_REPEAT_OPCODE(ZEND_RECV_INIT);
4771 ZEND_VM_NEXT_OPCODE();
4772 }
4773
4774 ZEND_VM_HANDLER(164, ZEND_RECV_VARIADIC, ANY, ANY)
4775 {
4776 USE_OPLINE
4777 uint32_t arg_num = opline->op1.num;
4778 uint32_t arg_count = EX_NUM_ARGS();
4779 zval *params;
4780
4781 SAVE_OPLINE();
4782
4783 params = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
4784
4785 if (arg_num <= arg_count) {
4786 zval *param;
4787
4788 array_init_size(params, arg_count - arg_num + 1);
4789 zend_hash_real_init(Z_ARRVAL_P(params), 1);
4790 ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(params)) {
4791 param = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
4792 if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
4793 do {
4794 zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num));
4795 if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4796 ZEND_HASH_FILL_ADD(param);
4797 param++;
4798 } while (++arg_num <= arg_count);
4799 } else {
4800 do {
4801 if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4802 ZEND_HASH_FILL_ADD(param);
4803 param++;
4804 } while (++arg_num <= arg_count);
4805 }
4806 } ZEND_HASH_FILL_END();
4807 } else {
4808 array_init(params);
4809 }
4810
4811 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4812 }
4813
4814 ZEND_VM_HANDLER(52, ZEND_BOOL, CONST|TMPVAR|CV, ANY)
4815 {
4816 USE_OPLINE
4817 zval *val;
4818 zend_free_op free_op1;
4819
4820 val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
4821 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4822 ZVAL_TRUE(EX_VAR(opline->result.var));
4823 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4824 ZVAL_FALSE(EX_VAR(opline->result.var));
4825 if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4826 SAVE_OPLINE();
4827 GET_OP1_UNDEF_CV(val, BP_VAR_R);
4828 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4829 }
4830 } else {
4831 SAVE_OPLINE();
4832 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
4833 FREE_OP1();
4834 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4835 }
4836 ZEND_VM_NEXT_OPCODE();
4837 }
4838
4839 ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
4840 {
4841 USE_OPLINE
4842 zend_free_op free_op1, free_op2;
4843 zval *op1, *op2, *result;
4844
4845 op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
4846 op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
4847 do {
4848 int result;
4849
4850 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
4851 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
4852 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
4853 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
4854 result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
4855 } else {
4856 break;
4857 }
4858 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
4859 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
4860 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
4861 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
4862 result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
4863 } else {
4864 break;
4865 }
4866 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
4867 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
4868 if (Z_STR_P(op1) == Z_STR_P(op2)) {
4869 result = 1;
4870 } else if (Z_STRVAL_P(op1)[0] > '9' || Z_STRVAL_P(op2)[0] > '9') {
4871 if (Z_STRLEN_P(op1) != Z_STRLEN_P(op2)) {
4872 result = 0;
4873 } else {
4874 result = (memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) == 0);
4875 }
4876 } else {
4877 result = (zendi_smart_strcmp(Z_STR_P(op1), Z_STR_P(op2)) == 0);
4878 }
4879 FREE_OP2();
4880 } else {
4881 break;
4882 }
4883 } else {
4884 break;
4885 }
4886 ZEND_VM_SMART_BRANCH(result, 0);
4887 ZVAL_BOOL(EX_VAR(opline->result.var), result);
4888 ZEND_VM_NEXT_OPCODE();
4889 } while (0);
4890
4891 SAVE_OPLINE();
4892 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
4893 op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
4894 } else if ((OP1_TYPE & (IS_VAR|IS_CV)) && UNEXPECTED(Z_ISREF_P(op1))) {
4895
4896 if (UNEXPECTED(Z_REFCOUNT_P(op1) == 1)) {
4897 ZVAL_UNREF(op1);
4898 } else {
4899 Z_DELREF_P(op1);
4900 ZVAL_COPY(op1, Z_REFVAL_P(op1));
4901 }
4902 }
4903 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
4904 op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
4905 }
4906 result = EX_VAR(opline->result.var);
4907 compare_function(result, op1, op2);
4908 ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
4909 FREE_OP2();
4910 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4911 }
4912
4913 ZEND_VM_HANDLER(68, ZEND_NEW, CONST|VAR, ANY)
4914 {
4915 USE_OPLINE
4916 zval object_zval;
4917 zend_function *constructor;
4918 zend_class_entry *ce;
4919
4920 SAVE_OPLINE();
4921 if (OP1_TYPE == IS_CONST) {
4922 ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
4923 if (UNEXPECTED(ce == NULL)) {
4924 ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
4925 if (UNEXPECTED(ce == NULL)) {
4926 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4927 }
4928 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce);
4929 }
4930 } else {
4931 ce = Z_CE_P(EX_VAR(opline->op1.var));
4932 }
4933 if (UNEXPECTED(object_init_ex(&object_zval, ce) != SUCCESS)) {
4934 HANDLE_EXCEPTION();
4935 }
4936 constructor = Z_OBJ_HT(object_zval)->get_constructor(Z_OBJ(object_zval));
4937
4938 if (constructor == NULL) {
4939 if (EXPECTED(RETURN_VALUE_USED(opline))) {
4940 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), &object_zval);
4941 } else {
4942 OBJ_RELEASE(Z_OBJ(object_zval));
4943 }
4944 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
4945 } else {
4946
4947 zend_execute_data *call = zend_vm_stack_push_call_frame(
4948 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_CTOR |
4949 (EXPECTED(RETURN_VALUE_USED(opline)) ? 0 : ZEND_CALL_CTOR_RESULT_UNUSED),
4950 constructor,
4951 opline->extended_value,
4952 ce,
4953 Z_OBJ(object_zval));
4954 call->prev_execute_data = EX(call);
4955 EX(call) = call;
4956
4957 if (EXPECTED(RETURN_VALUE_USED(opline))) {
4958 ZVAL_COPY(EX_VAR(opline->result.var), &object_zval);
4959 }
4960
4961 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4962 }
4963 }
4964
4965 ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMPVAR|UNUSED|CV, ANY)
4966 {
4967 USE_OPLINE
4968 zend_free_op free_op1;
4969 zval *obj;
4970 zend_class_entry *ce;
4971 zend_function *clone;
4972 zend_object_clone_obj_t clone_call;
4973
4974 SAVE_OPLINE();
4975 obj = GET_OP1_OBJ_ZVAL_PTR_UNDEF(BP_VAR_R);
4976
4977 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(obj) == NULL)) {
4978 zend_throw_error(NULL, "Using $this when not in object context");
4979 HANDLE_EXCEPTION();
4980 }
4981
4982 do {
4983 if (OP1_TYPE == IS_CONST ||
4984 (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
4985 if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
4986 obj = Z_REFVAL_P(obj);
4987 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
4988 break;
4989 }
4990 }
4991 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
4992 GET_OP1_UNDEF_CV(obj, BP_VAR_R);
4993 if (UNEXPECTED(EG(exception) != NULL)) {
4994 HANDLE_EXCEPTION();
4995 }
4996 }
4997 zend_throw_error(NULL, "__clone method called on non-object");
4998 FREE_OP1();
4999 HANDLE_EXCEPTION();
5000 }
5001 } while (0);
5002
5003 ce = Z_OBJCE_P(obj);
5004 clone = ce ? ce->clone : NULL;
5005 clone_call = Z_OBJ_HT_P(obj)->clone_obj;
5006 if (UNEXPECTED(clone_call == NULL)) {
5007 if (ce) {
5008 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
5009 } else {
5010 zend_throw_error(NULL, "Trying to clone an uncloneable object");
5011 }
5012 FREE_OP1();
5013 HANDLE_EXCEPTION();
5014 }
5015
5016 if (ce && clone) {
5017 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
5018
5019
5020 if (UNEXPECTED(ce != EG(scope))) {
5021 zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : "");
5022 FREE_OP1();
5023 HANDLE_EXCEPTION();
5024 }
5025 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
5026
5027
5028 if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
5029 zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : "");
5030 FREE_OP1();
5031 HANDLE_EXCEPTION();
5032 }
5033 }
5034 }
5035
5036 if (EXPECTED(EG(exception) == NULL)) {
5037 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj));
5038 if (UNEXPECTED(!RETURN_VALUE_USED(opline)) || UNEXPECTED(EG(exception) != NULL)) {
5039 OBJ_RELEASE(Z_OBJ_P(EX_VAR(opline->result.var)));
5040 }
5041 }
5042 FREE_OP1();
5043 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5044 }
5045
5046 ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
5047 {
5048 USE_OPLINE
5049
5050 SAVE_OPLINE();
5051 if (OP1_TYPE == IS_UNUSED) {
5052 zend_constant *c;
5053
5054 if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))))) {
5055 c = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
5056 } else if ((c = zend_quick_get_constant(EX_CONSTANT(opline->op2) + 1, opline->extended_value)) == NULL) {
5057 if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
5058 char *actual = (char *)zend_memrchr(Z_STRVAL_P(EX_CONSTANT(opline->op2)), '\\', Z_STRLEN_P(EX_CONSTANT(opline->op2)));
5059 if (!actual) {
5060 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_STR_P(EX_CONSTANT(opline->op2)));
5061 } else {
5062 actual++;
5063 ZVAL_STRINGL(EX_VAR(opline->result.var),
5064 actual, Z_STRLEN_P(EX_CONSTANT(opline->op2)) - (actual - Z_STRVAL_P(EX_CONSTANT(opline->op2))));
5065 }
5066
5067 zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
5068 Z_STRVAL_P(EX_VAR(opline->result.var)), Z_STRVAL_P(EX_VAR(opline->result.var)));
5069 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5070 } else {
5071 zend_throw_error(NULL, "Undefined constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2)));
5072 HANDLE_EXCEPTION();
5073 }
5074 } else {
5075 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), c);
5076 }
5077 #ifdef ZTS
5078 if (c->flags & CONST_PERSISTENT) {
5079 ZVAL_DUP(EX_VAR(opline->result.var), &c->value);
5080 } else {
5081 ZVAL_COPY(EX_VAR(opline->result.var), &c->value);
5082 }
5083 #else
5084 ZVAL_COPY(EX_VAR(opline->result.var), &c->value);
5085 #endif
5086 } else {
5087
5088 zend_class_entry *ce;
5089 zval *value;
5090
5091 do {
5092 if (OP1_TYPE == IS_CONST) {
5093 if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))))) {
5094 value = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
5095 ZVAL_DEREF(value);
5096 #ifdef ZTS
5097 ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
5098 #endif
5099 break;
5100 } else if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))))) {
5101 ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
5102 } else {
5103 ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
5104 if (UNEXPECTED(ce == NULL)) {
5105 if (EXPECTED(!EG(exception))) {
5106 zend_throw_error(NULL, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1)));
5107 }
5108 HANDLE_EXCEPTION();
5109 }
5110 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce);
5111 }
5112 } else {
5113 ce = Z_CE_P(EX_VAR(opline->op1.var));
5114 if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce)) != NULL) {
5115 ZVAL_DEREF(value);
5116 break;
5117 }
5118 }
5119
5120 if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(EX_CONSTANT(opline->op2)))) != NULL)) {
5121 ZVAL_DEREF(value);
5122 if (Z_CONSTANT_P(value)) {
5123 EG(scope) = ce;
5124 zval_update_constant_ex(value, 1, NULL);
5125 EG(scope) = EX(func)->op_array.scope;
5126 if (UNEXPECTED(EG(exception) != NULL)) {
5127 HANDLE_EXCEPTION();
5128 }
5129 }
5130 if (OP1_TYPE == IS_CONST) {
5131 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), value);
5132 } else {
5133 CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce, value);
5134 }
5135 } else {
5136 zend_throw_error(NULL, "Undefined class constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2)));
5137 HANDLE_EXCEPTION();
5138 }
5139 } while (0);
5140 #ifdef ZTS
5141 if (ce->type == ZEND_INTERNAL_CLASS) {
5142 ZVAL_DUP(EX_VAR(opline->result.var), value);
5143 } else {
5144 ZVAL_COPY(EX_VAR(opline->result.var), value);
5145 }
5146 #else
5147 ZVAL_COPY(EX_VAR(opline->result.var), value);
5148 #endif
5149 }
5150 ZEND_VM_NEXT_OPCODE();
5151 }
5152
5153 ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUSED|CV)
5154 {
5155 USE_OPLINE
5156 zend_free_op free_op1;
5157 zval *expr_ptr, new_expr;
5158
5159 SAVE_OPLINE();
5160 if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) &&
5161 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
5162 expr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
5163 if (OP1_TYPE == IS_VAR && UNEXPECTED(expr_ptr == NULL)) {
5164 zend_throw_error(NULL, "Cannot create references to/from string offsets");
5165 zend_array_destroy(Z_ARRVAL_P(EX_VAR(opline->result.var)));
5166 HANDLE_EXCEPTION();
5167 }
5168 ZVAL_MAKE_REF(expr_ptr);
5169 Z_ADDREF_P(expr_ptr);
5170 FREE_OP1_VAR_PTR();
5171 } else {
5172 expr_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
5173 if (OP1_TYPE == IS_TMP_VAR) {
5174
5175 } else if (OP1_TYPE == IS_CONST) {
5176 if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
5177 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
5178 zval_copy_ctor_func(&new_expr);
5179 expr_ptr = &new_expr;
5180 }
5181 } else if (OP1_TYPE == IS_CV) {
5182 ZVAL_DEREF(expr_ptr);
5183 if (Z_REFCOUNTED_P(expr_ptr)) {
5184 Z_ADDREF_P(expr_ptr);
5185 }
5186 } else {
5187 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
5188 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
5189
5190 expr_ptr = Z_REFVAL_P(expr_ptr);
5191 if (UNEXPECTED(--GC_REFCOUNT(ref) == 0)) {
5192 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
5193 expr_ptr = &new_expr;
5194 efree_size(ref, sizeof(zend_reference));
5195 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
5196 Z_ADDREF_P(expr_ptr);
5197 }
5198 }
5199 }
5200 }
5201
5202 if (OP2_TYPE != IS_UNUSED) {
5203 zend_free_op free_op2;
5204 zval *offset = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
5205 zend_string *str;
5206 zend_ulong hval;
5207
5208 ZEND_VM_C_LABEL(add_again):
5209 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
5210 str = Z_STR_P(offset);
5211 if (OP2_TYPE != IS_CONST) {
5212 if (ZEND_HANDLE_NUMERIC(str, hval)) {
5213 ZEND_VM_C_GOTO(num_index);
5214 }
5215 }
5216 ZEND_VM_C_LABEL(str_index):
5217 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
5218 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
5219 hval = Z_LVAL_P(offset);
5220 ZEND_VM_C_LABEL(num_index):
5221 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
5222 } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
5223 offset = Z_REFVAL_P(offset);
5224 ZEND_VM_C_GOTO(add_again);
5225 } else if (Z_TYPE_P(offset) == IS_NULL) {
5226 str = ZSTR_EMPTY_ALLOC();
5227 ZEND_VM_C_GOTO(str_index);
5228 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
5229 hval = zend_dval_to_lval(Z_DVAL_P(offset));
5230 ZEND_VM_C_GOTO(num_index);
5231 } else if (Z_TYPE_P(offset) == IS_FALSE) {
5232 hval = 0;
5233 ZEND_VM_C_GOTO(num_index);
5234 } else if (Z_TYPE_P(offset) == IS_TRUE) {
5235 hval = 1;
5236 ZEND_VM_C_GOTO(num_index);
5237 } else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
5238 GET_OP2_UNDEF_CV(offset, BP_VAR_R);
5239 str = ZSTR_EMPTY_ALLOC();
5240 ZEND_VM_C_GOTO(str_index);
5241 } else {
5242 zend_error(E_WARNING, "Illegal offset type");
5243 zval_ptr_dtor(expr_ptr);
5244 }
5245 FREE_OP2();
5246 } else {
5247 zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
5248 }
5249 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5250 }
5251
5252 ZEND_VM_HANDLER(71, ZEND_INIT_ARRAY, CONST|TMP|VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
5253 {
5254 zval *array;
5255 uint32_t size;
5256 USE_OPLINE
5257
5258 array = EX_VAR(opline->result.var);
5259 if (OP1_TYPE != IS_UNUSED) {
5260 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
5261 } else {
5262 size = 0;
5263 }
5264 ZVAL_NEW_ARR(array);
5265 zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
5266
5267 if (OP1_TYPE != IS_UNUSED) {
5268
5269 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
5270 zend_hash_real_init(Z_ARRVAL_P(array), 0);
5271 }
5272 }
5273
5274 if (OP1_TYPE == IS_UNUSED) {
5275 ZEND_VM_NEXT_OPCODE();
5276 #if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
5277 } else {
5278 ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ADD_ARRAY_ELEMENT);
5279 #endif
5280 }
5281 }
5282
5283 ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)
5284 {
5285 USE_OPLINE
5286 zend_free_op free_op1;
5287 zval *expr;
5288 zval *result = EX_VAR(opline->result.var);
5289
5290 SAVE_OPLINE();
5291 expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
5292
5293 switch (opline->extended_value) {
5294 case IS_NULL:
5295
5296
5297
5298 #if 0
5299 if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
5300 ZVAL_DEREF(expr);
5301 }
5302 if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->cast_object) {
5303 if (Z_OBJ_HT_P(expr)->cast_object(expr, result, IS_NULL) == SUCCESS) {
5304 break;
5305 }
5306 }
5307 #endif
5308
5309 ZVAL_NULL(result);
5310 break;
5311 case _IS_BOOL:
5312 ZVAL_BOOL(result, zend_is_true(expr));
5313 break;
5314 case IS_LONG:
5315 ZVAL_LONG(result, zval_get_long(expr));
5316 break;
5317 case IS_DOUBLE:
5318 ZVAL_DOUBLE(result, zval_get_double(expr));
5319 break;
5320 case IS_STRING:
5321 ZVAL_STR(result, zval_get_string(expr));
5322 break;
5323 default:
5324 if (OP1_TYPE & (IS_VAR|IS_CV)) {
5325 ZVAL_DEREF(expr);
5326 }
5327
5328 if (Z_TYPE_P(expr) == opline->extended_value) {
5329 ZVAL_COPY_VALUE(result, expr);
5330 if (OP1_TYPE == IS_CONST) {
5331 if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
5332 zval_copy_ctor_func(result);
5333 }
5334 } else if (OP1_TYPE != IS_TMP_VAR) {
5335 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
5336 }
5337
5338 FREE_OP1_IF_VAR();
5339 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5340 }
5341
5342 if (opline->extended_value == IS_ARRAY) {
5343 if (Z_TYPE_P(expr) != IS_OBJECT) {
5344 ZVAL_NEW_ARR(result);
5345 zend_hash_init(Z_ARRVAL_P(result), 8, NULL, ZVAL_PTR_DTOR, 0);
5346 if (Z_TYPE_P(expr) != IS_NULL) {
5347 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
5348 if (OP1_TYPE == IS_CONST) {
5349 if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
5350 zval_copy_ctor_func(expr);
5351 }
5352 } else {
5353 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
5354 }
5355 }
5356 } else {
5357 ZVAL_COPY_VALUE(result, expr);
5358 Z_ADDREF_P(result);
5359 convert_to_array(result);
5360 }
5361 } else {
5362 if (Z_TYPE_P(expr) != IS_ARRAY) {
5363 object_init(result);
5364 if (Z_TYPE_P(expr) != IS_NULL) {
5365 expr = zend_hash_str_add_new(Z_OBJPROP_P(result), "scalar", sizeof("scalar")-1, expr);
5366 if (OP1_TYPE == IS_CONST) {
5367 if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
5368 zval_copy_ctor_func(expr);
5369 }
5370 } else {
5371 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
5372 }
5373 }
5374 } else {
5375 ZVAL_COPY(result, expr);
5376 convert_to_object(result);
5377 }
5378 }
5379 }
5380
5381 FREE_OP1();
5382 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5383 }
5384
5385 ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY)
5386 {
5387 USE_OPLINE
5388 zend_op_array *new_op_array=NULL;
5389 zend_free_op free_op1;
5390 zval *inc_filename;
5391 zval tmp_inc_filename;
5392 zend_bool failure_retval=0;
5393
5394 SAVE_OPLINE();
5395 inc_filename = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
5396
5397 ZVAL_UNDEF(&tmp_inc_filename);
5398 if (Z_TYPE_P(inc_filename) != IS_STRING) {
5399 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(inc_filename) == IS_UNDEF)) {
5400 inc_filename = GET_OP1_UNDEF_CV(inc_filename, BP_VAR_R);
5401 }
5402 ZVAL_STR(&tmp_inc_filename, zval_get_string(inc_filename));
5403 inc_filename = &tmp_inc_filename;
5404 }
5405
5406 if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
5407 if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
5408 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename));
5409 } else {
5410 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
5411 }
5412 } else {
5413 switch (opline->extended_value) {
5414 case ZEND_INCLUDE_ONCE:
5415 case ZEND_REQUIRE_ONCE: {
5416 zend_file_handle file_handle;
5417 zend_string *resolved_path;
5418
5419 resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), (int)Z_STRLEN_P(inc_filename));
5420 if (resolved_path) {
5421 failure_retval = zend_hash_exists(&EG(included_files), resolved_path);
5422 } else {
5423 resolved_path = zend_string_copy(Z_STR_P(inc_filename));
5424 }
5425
5426 if (failure_retval) {
5427
5428 } else if (SUCCESS == zend_stream_open(ZSTR_VAL(resolved_path), &file_handle)) {
5429
5430 if (!file_handle.opened_path) {
5431 file_handle.opened_path = zend_string_copy(resolved_path);
5432 }
5433
5434 if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path)) {
5435 new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE));
5436 zend_destroy_file_handle(&file_handle);
5437 } else {
5438 zend_file_handle_dtor(&file_handle);
5439 failure_retval=1;
5440 }
5441 } else {
5442 if (opline->extended_value == ZEND_INCLUDE_ONCE) {
5443 zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename));
5444 } else {
5445 zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
5446 }
5447 }
5448 zend_string_release(resolved_path);
5449 }
5450 break;
5451 case ZEND_INCLUDE:
5452 case ZEND_REQUIRE:
5453 new_op_array = compile_filename(opline->extended_value, inc_filename);
5454 break;
5455 case ZEND_EVAL: {
5456 char *eval_desc = zend_make_compiled_string_description("eval()'d code");
5457
5458 new_op_array = zend_compile_string(inc_filename, eval_desc);
5459 efree(eval_desc);
5460 }
5461 break;
5462 EMPTY_SWITCH_DEFAULT_CASE()
5463 }
5464 }
5465 if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) {
5466 zend_string_release(Z_STR(tmp_inc_filename));
5467 }
5468 FREE_OP1();
5469 if (UNEXPECTED(EG(exception) != NULL)) {
5470 HANDLE_EXCEPTION();
5471 } else if (EXPECTED(new_op_array != NULL)) {
5472 zval *return_value = NULL;
5473 zend_execute_data *call;
5474
5475 if (RETURN_VALUE_USED(opline)) {
5476 return_value = EX_VAR(opline->result.var);
5477 }
5478
5479 new_op_array->scope = EG(scope);
5480
5481 call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE,
5482 (zend_function*)new_op_array, 0, EX(called_scope), Z_OBJ(EX(This)));
5483
5484 if (EX(symbol_table)) {
5485 call->symbol_table = EX(symbol_table);
5486 } else {
5487 call->symbol_table = zend_rebuild_symbol_table();
5488 }
5489
5490 call->prev_execute_data = execute_data;
5491 i_init_code_execute_data(call, new_op_array, return_value);
5492 if (EXPECTED(zend_execute_ex == execute_ex)) {
5493 ZEND_VM_ENTER();
5494 } else {
5495 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5496 zend_execute_ex(call);
5497 zend_vm_stack_free_call_frame(call);
5498 }
5499
5500 destroy_op_array(new_op_array);
5501 efree_size(new_op_array, sizeof(zend_op_array));
5502 if (UNEXPECTED(EG(exception) != NULL)) {
5503 zend_throw_exception_internal(NULL);
5504 HANDLE_EXCEPTION();
5505 }
5506
5507 } else if (RETURN_VALUE_USED(opline)) {
5508 ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval);
5509 }
5510 ZEND_VM_INTERRUPT_CHECK();
5511 ZEND_VM_NEXT_OPCODE();
5512 }
5513
5514 ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
5515 {
5516 USE_OPLINE
5517 zval tmp, *varname;
5518 HashTable *target_symbol_table;
5519 zend_free_op free_op1;
5520
5521 SAVE_OPLINE();
5522 if (OP1_TYPE == IS_CV &&
5523 OP2_TYPE == IS_UNUSED &&
5524 (opline->extended_value & ZEND_QUICK_SET)) {
5525 zval *var = EX_VAR(opline->op1.var);
5526
5527 if (Z_REFCOUNTED_P(var)) {
5528 zend_refcounted *garbage = Z_COUNTED_P(var);
5529
5530 if (!--GC_REFCOUNT(garbage)) {
5531 ZVAL_UNDEF(var);
5532 zval_dtor_func_for_ptr(garbage);
5533 } else {
5534 zval *z = var;
5535 ZVAL_DEREF(z);
5536 if (Z_COLLECTABLE_P(z) && UNEXPECTED(!Z_GC_INFO_P(z))) {
5537 ZVAL_UNDEF(var);
5538 gc_possible_root(Z_COUNTED_P(z));
5539 } else {
5540 ZVAL_UNDEF(var);
5541 }
5542 }
5543 } else {
5544 ZVAL_UNDEF(var);
5545 }
5546 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5547 }
5548
5549 varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
5550
5551 ZVAL_UNDEF(&tmp);
5552 if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
5553 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
5554 varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
5555 }
5556 ZVAL_STR(&tmp, zval_get_string(varname));
5557 varname = &tmp;
5558 }
5559
5560 if (OP2_TYPE != IS_UNUSED) {
5561 zend_class_entry *ce;
5562
5563 if (OP2_TYPE == IS_CONST) {
5564 ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
5565 if (UNEXPECTED(ce == NULL)) {
5566 ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
5567 if (UNEXPECTED(ce == NULL)) {
5568 if (EXPECTED(!EG(exception))) {
5569 zend_throw_error(NULL, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2)));
5570 }
5571 if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
5572 zend_string_release(Z_STR(tmp));
5573 }
5574 FREE_OP1();
5575 HANDLE_EXCEPTION();
5576 }
5577 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
5578 }
5579 } else {
5580 ce = Z_CE_P(EX_VAR(opline->op2.var));
5581 }
5582 zend_std_unset_static_property(ce, Z_STR_P(varname));
5583 } else {
5584 target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
5585 zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
5586 }
5587
5588 if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
5589 zend_string_release(Z_STR(tmp));
5590 }
5591 FREE_OP1();
5592 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5593 }
5594
5595 ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMPVAR|CV)
5596 {
5597 USE_OPLINE
5598 zend_free_op free_op1, free_op2;
5599 zval *container;
5600 zval *offset;
5601 zend_ulong hval;
5602 zend_string *key;
5603
5604 SAVE_OPLINE();
5605 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
5606 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
5607 zend_throw_error(NULL, "Using $this when not in object context");
5608 FREE_UNFETCHED_OP2();
5609 HANDLE_EXCEPTION();
5610 }
5611 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
5612 zend_throw_error(NULL, "Cannot unset string offsets");
5613 FREE_UNFETCHED_OP2();
5614 HANDLE_EXCEPTION();
5615 }
5616 offset = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
5617
5618 do {
5619 if (OP1_TYPE != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
5620 HashTable *ht;
5621
5622 ZEND_VM_C_LABEL(unset_dim_array):
5623 SEPARATE_ARRAY(container);
5624 ht = Z_ARRVAL_P(container);
5625 ZEND_VM_C_LABEL(offset_again):
5626 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
5627 key = Z_STR_P(offset);
5628 if (OP2_TYPE != IS_CONST) {
5629 if (ZEND_HANDLE_NUMERIC(key, hval)) {
5630 ZEND_VM_C_GOTO(num_index_dim);
5631 }
5632 }
5633 ZEND_VM_C_LABEL(str_index_dim):
5634 if (ht == &EG(symbol_table)) {
5635 zend_delete_global_variable(key);
5636 } else {
5637 zend_hash_del(ht, key);
5638 }
5639 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
5640 hval = Z_LVAL_P(offset);
5641 ZEND_VM_C_LABEL(num_index_dim):
5642 zend_hash_index_del(ht, hval);
5643 } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
5644 offset = Z_REFVAL_P(offset);
5645 ZEND_VM_C_GOTO(offset_again);
5646 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
5647 hval = zend_dval_to_lval(Z_DVAL_P(offset));
5648 ZEND_VM_C_GOTO(num_index_dim);
5649 } else if (Z_TYPE_P(offset) == IS_NULL) {
5650 key = ZSTR_EMPTY_ALLOC();
5651 ZEND_VM_C_GOTO(str_index_dim);
5652 } else if (Z_TYPE_P(offset) == IS_FALSE) {
5653 hval = 0;
5654 ZEND_VM_C_GOTO(num_index_dim);
5655 } else if (Z_TYPE_P(offset) == IS_TRUE) {
5656 hval = 1;
5657 ZEND_VM_C_GOTO(num_index_dim);
5658 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
5659 hval = Z_RES_HANDLE_P(offset);
5660 ZEND_VM_C_GOTO(num_index_dim);
5661 } else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
5662 GET_OP2_UNDEF_CV(offset, BP_VAR_R);
5663 key = ZSTR_EMPTY_ALLOC();
5664 ZEND_VM_C_GOTO(str_index_dim);
5665 } else {
5666 zend_error(E_WARNING, "Illegal offset type in unset");
5667 }
5668 break;
5669 } else if (OP1_TYPE != IS_UNUSED && Z_ISREF_P(container)) {
5670 container = Z_REFVAL_P(container);
5671 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
5672 ZEND_VM_C_GOTO(unset_dim_array);
5673 }
5674 }
5675 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
5676 offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R);
5677 }
5678 if (OP1_TYPE == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
5679 if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
5680 zend_throw_error(NULL, "Cannot use object as array");
5681 } else {
5682 Z_OBJ_HT_P(container)->unset_dimension(container, offset);
5683 }
5684 } else if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
5685 zend_throw_error(NULL, "Cannot unset string offsets");
5686 }
5687 } while (0);
5688
5689 FREE_OP2();
5690 FREE_OP1_VAR_PTR();
5691 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5692 }
5693
5694 ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
5695 {
5696 USE_OPLINE
5697 zend_free_op free_op1, free_op2;
5698 zval *container;
5699 zval *offset;
5700
5701 SAVE_OPLINE();
5702 container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
5703 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
5704 zend_throw_error(NULL, "Using $this when not in object context");
5705 FREE_UNFETCHED_OP2();
5706 HANDLE_EXCEPTION();
5707 }
5708 if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
5709 zend_throw_error(NULL, "Cannot unset string offsets");
5710 FREE_UNFETCHED_OP2();
5711 HANDLE_EXCEPTION();
5712 }
5713 offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
5714
5715 do {
5716 if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
5717 if (Z_ISREF_P(container)) {
5718 container = Z_REFVAL_P(container);
5719 if (Z_TYPE_P(container) != IS_OBJECT) {
5720 break;
5721 }
5722 } else {
5723 break;
5724 }
5725 }
5726 if (Z_OBJ_HT_P(container)->unset_property) {
5727 Z_OBJ_HT_P(container)->unset_property(container, offset, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
5728 } else {
5729 zend_error(E_NOTICE, "Trying to unset property of non-object");
5730 }
5731 } while (0);
5732
5733 FREE_OP2();
5734 FREE_OP1_VAR_PTR();
5735 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5736 }
5737
5738 ZEND_VM_HANDLER(77, ZEND_FE_RESET_R, CONST|TMP|VAR|CV, ANY)
5739 {
5740 USE_OPLINE
5741 zend_free_op free_op1;
5742 zval *array_ptr, *result;
5743 HashTable *fe_ht;
5744
5745 SAVE_OPLINE();
5746
5747 array_ptr = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
5748 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5749 result = EX_VAR(opline->result.var);
5750 ZVAL_COPY_VALUE(result, array_ptr);
5751 if (OP1_TYPE != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
5752 Z_ADDREF_P(array_ptr);
5753 }
5754 Z_FE_POS_P(result) = 0;
5755
5756 FREE_OP1_IF_VAR();
5757 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5758 } else if (OP1_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5759 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
5760 HashPosition pos = 0;
5761 Bucket *p;
5762
5763 result = EX_VAR(opline->result.var);
5764 ZVAL_COPY_VALUE(result, array_ptr);
5765 if (OP1_TYPE != IS_TMP_VAR) {
5766 Z_ADDREF_P(array_ptr);
5767 }
5768 fe_ht = Z_OBJPROP_P(array_ptr);
5769 pos = 0;
5770 p = fe_ht->arData;
5771 while (1) {
5772 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
5773 FREE_OP1_IF_VAR();
5774 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5775 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5776 }
5777 if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
5778 (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
5779 EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
5780 (UNEXPECTED(!p->key) ||
5781 EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
5782 break;
5783 }
5784 pos++;
5785 p++;
5786 }
5787 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(fe_ht, pos);
5788
5789 FREE_OP1_IF_VAR();
5790 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5791 } else {
5792 zend_class_entry *ce = Z_OBJCE_P(array_ptr);
5793 zend_object_iterator *iter = ce->get_iterator(ce, array_ptr, 0);
5794 zend_bool is_empty;
5795
5796 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
5797 FREE_OP1();
5798 if (!EG(exception)) {
5799 zend_throw_exception_ex(NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
5800 }
5801 zend_throw_exception_internal(NULL);
5802 HANDLE_EXCEPTION();
5803 }
5804
5805 iter->index = 0;
5806 if (iter->funcs->rewind) {
5807 iter->funcs->rewind(iter);
5808 if (UNEXPECTED(EG(exception) != NULL)) {
5809 OBJ_RELEASE(&iter->std);
5810 FREE_OP1();
5811 HANDLE_EXCEPTION();
5812 }
5813 }
5814
5815 is_empty = iter->funcs->valid(iter) != SUCCESS;
5816
5817 if (UNEXPECTED(EG(exception) != NULL)) {
5818 OBJ_RELEASE(&iter->std);
5819 FREE_OP1();
5820 HANDLE_EXCEPTION();
5821 }
5822 iter->index = -1;
5823
5824 ZVAL_OBJ(EX_VAR(opline->result.var), &iter->std);
5825 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5826
5827 FREE_OP1();
5828 if (is_empty) {
5829 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5830 } else {
5831 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5832 }
5833 }
5834 } else {
5835 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
5836 ZVAL_UNDEF(EX_VAR(opline->result.var));
5837 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5838 FREE_OP1();
5839 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5840 }
5841 }
5842
5843 ZEND_VM_HANDLER(125, ZEND_FE_RESET_RW, CONST|TMP|VAR|CV, ANY)
5844 {
5845 USE_OPLINE
5846 zend_free_op free_op1;
5847 zval *array_ptr, *array_ref;
5848 HashTable *fe_ht;
5849 HashPosition pos = 0;
5850 Bucket *p;
5851
5852 SAVE_OPLINE();
5853
5854 if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
5855 array_ref = array_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
5856 if (Z_ISREF_P(array_ref)) {
5857 array_ptr = Z_REFVAL_P(array_ref);
5858 }
5859 } else {
5860 array_ref = array_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
5861 }
5862
5863 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5864 if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
5865 if (array_ptr == array_ref) {
5866 ZVAL_NEW_REF(array_ref, array_ref);
5867 array_ptr = Z_REFVAL_P(array_ref);
5868 }
5869 Z_ADDREF_P(array_ref);
5870 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5871 } else {
5872 array_ref = EX_VAR(opline->result.var);
5873 ZVAL_NEW_REF(array_ref, array_ptr);
5874 array_ptr = Z_REFVAL_P(array_ref);
5875 }
5876 if (OP1_TYPE == IS_CONST) {
5877 zval_copy_ctor_func(array_ptr);
5878 } else {
5879 SEPARATE_ARRAY(array_ptr);
5880 }
5881 fe_ht = Z_ARRVAL_P(array_ptr);
5882 p = fe_ht->arData;
5883 while (1) {
5884 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
5885 FREE_OP1_VAR_PTR();
5886 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5887 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5888 }
5889 if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
5890 (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
5891 EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) {
5892 break;
5893 }
5894 pos++;
5895 p++;
5896 }
5897 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(fe_ht, pos);
5898
5899 FREE_OP1_VAR_PTR();
5900 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5901 } else if (OP1_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5902 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
5903 if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
5904 if (array_ptr == array_ref) {
5905 ZVAL_NEW_REF(array_ref, array_ref);
5906 array_ptr = Z_REFVAL_P(array_ref);
5907 }
5908 Z_ADDREF_P(array_ref);
5909 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5910 } else {
5911 array_ptr = EX_VAR(opline->result.var);
5912 ZVAL_COPY_VALUE(array_ptr, array_ref);
5913 }
5914 fe_ht = Z_OBJPROP_P(array_ptr);
5915 p = fe_ht->arData;
5916 while (1) {
5917 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
5918 FREE_OP1_VAR_PTR();
5919 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5920 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5921 }
5922 if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
5923 (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
5924 EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
5925 (UNEXPECTED(!p->key) ||
5926 EXPECTED(zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS))) {
5927 break;
5928 }
5929 pos++;
5930 p++;
5931 }
5932 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(fe_ht, pos);
5933
5934 FREE_OP1_VAR_PTR();
5935 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5936 } else {
5937 zend_class_entry *ce = Z_OBJCE_P(array_ptr);
5938 zend_object_iterator *iter = ce->get_iterator(ce, array_ptr, 1);
5939 zend_bool is_empty;
5940
5941 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
5942 if (OP1_TYPE == IS_VAR) {
5943 FREE_OP1_VAR_PTR();
5944 } else {
5945 FREE_OP1();
5946 }
5947 if (!EG(exception)) {
5948 zend_throw_exception_ex(NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
5949 }
5950 zend_throw_exception_internal(NULL);
5951 HANDLE_EXCEPTION();
5952 }
5953
5954 iter->index = 0;
5955 if (iter->funcs->rewind) {
5956 iter->funcs->rewind(iter);
5957 if (UNEXPECTED(EG(exception) != NULL)) {
5958 OBJ_RELEASE(&iter->std);
5959 if (OP1_TYPE == IS_VAR) {
5960 FREE_OP1_VAR_PTR();
5961 } else {
5962 FREE_OP1();
5963 }
5964 HANDLE_EXCEPTION();
5965 }
5966 }
5967
5968 is_empty = iter->funcs->valid(iter) != SUCCESS;
5969
5970 if (UNEXPECTED(EG(exception) != NULL)) {
5971 OBJ_RELEASE(&iter->std);
5972 if (OP1_TYPE == IS_VAR) {
5973 FREE_OP1_VAR_PTR();
5974 } else {
5975 FREE_OP1();
5976 }
5977 HANDLE_EXCEPTION();
5978 }
5979 iter->index = -1;
5980
5981 ZVAL_OBJ(EX_VAR(opline->result.var), &iter->std);
5982 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5983
5984 if (OP1_TYPE == IS_VAR) {
5985 FREE_OP1_VAR_PTR();
5986 } else {
5987 FREE_OP1();
5988 }
5989 if (is_empty) {
5990 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5991 } else {
5992 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5993 }
5994 }
5995 } else {
5996 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
5997 ZVAL_UNDEF(EX_VAR(opline->result.var));
5998 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5999 if (OP1_TYPE == IS_VAR) {
6000 FREE_OP1_VAR_PTR();
6001 } else {
6002 FREE_OP1();
6003 }
6004 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
6005 }
6006 }
6007
6008 ZEND_VM_HANDLER(78, ZEND_FE_FETCH_R, VAR, ANY)
6009 {
6010 USE_OPLINE
6011 zval *array;
6012 zval *value;
6013 uint32_t value_type;
6014 HashTable *fe_ht;
6015 HashPosition pos;
6016 Bucket *p;
6017
6018 array = EX_VAR(opline->op1.var);
6019 SAVE_OPLINE();
6020 if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
6021 fe_ht = Z_ARRVAL_P(array);
6022 pos = Z_FE_POS_P(array);
6023 p = fe_ht->arData + pos;
6024 while (1) {
6025 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
6026
6027 ZEND_VM_C_GOTO(fe_fetch_r_exit);
6028 }
6029 value = &p->val;
6030 value_type = Z_TYPE_INFO_P(value);
6031 if (value_type == IS_UNDEF) {
6032 pos++;
6033 p++;
6034 continue;
6035 } else if (UNEXPECTED(value_type == IS_INDIRECT)) {
6036 value = Z_INDIRECT_P(value);
6037 value_type = Z_TYPE_INFO_P(value);
6038 if (UNEXPECTED(value_type == IS_UNDEF)) {
6039 pos++;
6040 p++;
6041 continue;
6042 }
6043 }
6044 break;
6045 }
6046 Z_FE_POS_P(array) = pos + 1;
6047 if (opline->result_type == IS_TMP_VAR) {
6048 if (!p->key) {
6049 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
6050 } else {
6051 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
6052 }
6053 }
6054 } else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
6055 zend_object_iterator *iter;
6056
6057 if ((iter = zend_iterator_unwrap(array)) == NULL) {
6058
6059
6060 fe_ht = Z_OBJPROP_P(array);
6061 pos = zend_hash_iterator_pos(Z_FE_ITER_P(array), fe_ht);
6062 p = fe_ht->arData + pos;
6063 while (1) {
6064 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
6065
6066 ZEND_VM_C_GOTO(fe_fetch_r_exit);
6067 }
6068
6069 value = &p->val;
6070 value_type = Z_TYPE_INFO_P(value);
6071 if (UNEXPECTED(value_type == IS_UNDEF)) {
6072 pos++;
6073 p++;
6074 continue;
6075 } else if (UNEXPECTED(value_type == IS_INDIRECT)) {
6076 value = Z_INDIRECT_P(value);
6077 value_type = Z_TYPE_INFO_P(value);
6078 if (UNEXPECTED(value_type == IS_UNDEF)) {
6079 pos++;
6080 p++;
6081 continue;
6082 }
6083 }
6084 if (UNEXPECTED(!p->key) ||
6085 EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS)) {
6086 break;
6087 }
6088 pos++;
6089 p++;
6090 }
6091 if (opline->result_type == IS_TMP_VAR) {
6092 if (UNEXPECTED(!p->key)) {
6093 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
6094 } else if (ZSTR_VAL(p->key)[0]) {
6095 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
6096 } else {
6097 const char *class_name, *prop_name;
6098 size_t prop_name_len;
6099 zend_unmangle_property_name_ex(
6100 p->key, &class_name, &prop_name, &prop_name_len);
6101 ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
6102 }
6103 }
6104 while (1) {
6105 pos++;
6106 if (pos >= fe_ht->nNumUsed) {
6107 pos = HT_INVALID_IDX;
6108 break;
6109 }
6110 p++;
6111 if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
6112 (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
6113 EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
6114 (UNEXPECTED(!p->key) ||
6115 EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS))) {
6116 break;
6117 }
6118 }
6119 EG(ht_iterators)[Z_FE_ITER_P(array)].pos = pos;
6120 } else {
6121 if (EXPECTED(++iter->index > 0)) {
6122
6123
6124 iter->funcs->move_forward(iter);
6125 if (UNEXPECTED(EG(exception) != NULL)) {
6126 zval_ptr_dtor(array);
6127 HANDLE_EXCEPTION();
6128 }
6129 if (UNEXPECTED(iter->funcs->valid(iter) == FAILURE)) {
6130
6131 if (UNEXPECTED(EG(exception) != NULL)) {
6132 zval_ptr_dtor(array);
6133 HANDLE_EXCEPTION();
6134 }
6135 ZEND_VM_C_GOTO(fe_fetch_r_exit);
6136 }
6137 }
6138 value = iter->funcs->get_current_data(iter);
6139 if (UNEXPECTED(EG(exception) != NULL)) {
6140 zval_ptr_dtor(array);
6141 HANDLE_EXCEPTION();
6142 }
6143 if (!value) {
6144
6145 ZEND_VM_C_GOTO(fe_fetch_r_exit);
6146 }
6147 if (opline->result_type == IS_TMP_VAR) {
6148 if (iter->funcs->get_current_key) {
6149 iter->funcs->get_current_key(iter, EX_VAR(opline->result.var));
6150 if (UNEXPECTED(EG(exception) != NULL)) {
6151 zval_ptr_dtor(array);
6152 HANDLE_EXCEPTION();
6153 }
6154 } else {
6155 ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
6156 }
6157 }
6158 value_type = Z_TYPE_INFO_P(value);
6159 }
6160 } else {
6161 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
6162 if (UNEXPECTED(EG(exception))) {
6163 HANDLE_EXCEPTION();
6164 }
6165 ZEND_VM_C_LABEL(fe_fetch_r_exit):
6166 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
6167 ZEND_VM_CONTINUE();
6168 }
6169
6170 if (EXPECTED(OP2_TYPE == IS_CV)) {
6171 zval *variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op2.var);
6172 zend_assign_to_variable(variable_ptr, value, IS_CV);
6173 } else {
6174 zval *res = EX_VAR(opline->op2.var);
6175 zend_refcounted *gc = Z_COUNTED_P(value);
6176
6177 ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
6178 if (EXPECTED((value_type & (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT)) != 0)) {
6179 GC_REFCOUNT(gc)++;
6180 }
6181 }
6182 ZEND_VM_NEXT_OPCODE();
6183 }
6184
6185 ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY)
6186 {
6187 USE_OPLINE
6188 zval *array;
6189 zval *value;
6190 uint32_t value_type;
6191 HashTable *fe_ht;
6192 HashPosition pos;
6193 Bucket *p;
6194
6195 array = EX_VAR(opline->op1.var);
6196 SAVE_OPLINE();
6197
6198 ZVAL_DEREF(array);
6199 if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
6200 pos = zend_hash_iterator_pos_ex(Z_FE_ITER_P(EX_VAR(opline->op1.var)), array);
6201 fe_ht = Z_ARRVAL_P(array);
6202 p = fe_ht->arData + pos;
6203 while (1) {
6204 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
6205
6206 ZEND_VM_C_GOTO(fe_fetch_w_exit);
6207 }
6208 value = &p->val;
6209 value_type = Z_TYPE_INFO_P(value);
6210 if (UNEXPECTED(value_type == IS_UNDEF)) {
6211 pos++;
6212 p++;
6213 continue;
6214 } else if (UNEXPECTED(value_type == IS_INDIRECT)) {
6215 value = Z_INDIRECT_P(value);
6216 value_type = Z_TYPE_INFO_P(value);
6217 if (UNEXPECTED(value_type == IS_UNDEF)) {
6218 pos++;
6219 p++;
6220 continue;
6221 }
6222 }
6223 break;
6224 }
6225 if (opline->result_type == IS_TMP_VAR) {
6226 if (!p->key) {
6227 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
6228 } else {
6229 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
6230 }
6231 }
6232 while (1) {
6233 pos++;
6234 if (pos >= fe_ht->nNumUsed) {
6235 pos = HT_INVALID_IDX;
6236 break;
6237 }
6238 p++;
6239 if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
6240 (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
6241 EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) {
6242 break;
6243 }
6244 }
6245 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
6246 } else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
6247 zend_object_iterator *iter;
6248
6249 if ((iter = zend_iterator_unwrap(array)) == NULL) {
6250
6251
6252 fe_ht = Z_OBJPROP_P(array);
6253 pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
6254 p = fe_ht->arData + pos;
6255 while (1) {
6256 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
6257
6258 ZEND_VM_C_GOTO(fe_fetch_w_exit);
6259 }
6260
6261 value = &p->val;
6262 value_type = Z_TYPE_INFO_P(value);
6263 if (UNEXPECTED(value_type == IS_UNDEF)) {
6264 pos++;
6265 p++;
6266 continue;
6267 } else if (UNEXPECTED(value_type == IS_INDIRECT)) {
6268 value = Z_INDIRECT_P(value);
6269 value_type = Z_TYPE_INFO_P(value);
6270 if (UNEXPECTED(value_type == IS_UNDEF)) {
6271 pos++;
6272 p++;
6273 continue;
6274 }
6275 }
6276 if (UNEXPECTED(!p->key) ||
6277 EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS)) {
6278 break;
6279 }
6280 pos++;
6281 p++;
6282 }
6283 if (opline->result_type == IS_TMP_VAR) {
6284 if (UNEXPECTED(!p->key)) {
6285 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
6286 } else if (ZSTR_VAL(p->key)[0]) {
6287 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
6288 } else {
6289 const char *class_name, *prop_name;
6290 size_t prop_name_len;
6291 zend_unmangle_property_name_ex(
6292 p->key, &class_name, &prop_name, &prop_name_len);
6293 ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
6294 }
6295 }
6296 while (1) {
6297 pos++;
6298 if (pos >= fe_ht->nNumUsed) {
6299 pos = HT_INVALID_IDX;
6300 break;
6301 }
6302 p++;
6303 if ((EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
6304 (EXPECTED(Z_TYPE(p->val) != IS_INDIRECT) ||
6305 EXPECTED(Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF))) &&
6306 (UNEXPECTED(!p->key) ||
6307 EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS))) {
6308 break;
6309 }
6310 }
6311 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
6312 } else {
6313 if (++iter->index > 0) {
6314
6315
6316 iter->funcs->move_forward(iter);
6317 if (UNEXPECTED(EG(exception) != NULL)) {
6318 zval_ptr_dtor(array);
6319 HANDLE_EXCEPTION();
6320 }
6321 if (UNEXPECTED(iter->funcs->valid(iter) == FAILURE)) {
6322
6323 if (UNEXPECTED(EG(exception) != NULL)) {
6324 zval_ptr_dtor(array);
6325 HANDLE_EXCEPTION();
6326 }
6327 ZEND_VM_C_GOTO(fe_fetch_w_exit);
6328 }
6329 }
6330 value = iter->funcs->get_current_data(iter);
6331 if (UNEXPECTED(EG(exception) != NULL)) {
6332 zval_ptr_dtor(array);
6333 HANDLE_EXCEPTION();
6334 }
6335 if (!value) {
6336
6337 ZEND_VM_C_GOTO(fe_fetch_w_exit);
6338 }
6339 if (opline->result_type == IS_TMP_VAR) {
6340 if (iter->funcs->get_current_key) {
6341 iter->funcs->get_current_key(iter, EX_VAR(opline->result.var));
6342 if (UNEXPECTED(EG(exception) != NULL)) {
6343 zval_ptr_dtor(array);
6344 HANDLE_EXCEPTION();
6345 }
6346 } else {
6347 ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
6348 }
6349 }
6350 value_type = Z_TYPE_INFO_P(value);
6351 }
6352 } else {
6353 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
6354 if (UNEXPECTED(EG(exception))) {
6355 HANDLE_EXCEPTION();
6356 }
6357 ZEND_VM_C_LABEL(fe_fetch_w_exit):
6358 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
6359 ZEND_VM_CONTINUE();
6360 }
6361
6362 if (EXPECTED((value_type & Z_TYPE_MASK) != IS_REFERENCE)) {
6363 zend_refcounted *gc = Z_COUNTED_P(value);
6364 zval *ref;
6365 ZVAL_NEW_EMPTY_REF(value);
6366 ref = Z_REFVAL_P(value);
6367 ZVAL_COPY_VALUE_EX(ref, value, gc, value_type);
6368 }
6369 if (EXPECTED(OP2_TYPE == IS_CV)) {
6370 zval *variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op2.var);
6371 if (EXPECTED(variable_ptr != value)) {
6372 zend_reference *ref;
6373
6374 ref = Z_REF_P(value);
6375 GC_REFCOUNT(ref)++;
6376 zval_ptr_dtor(variable_ptr);
6377 ZVAL_REF(variable_ptr, ref);
6378 }
6379 } else {
6380 Z_ADDREF_P(value);
6381 ZVAL_REF(EX_VAR(opline->op2.var), Z_REF_P(value));
6382 }
6383 ZEND_VM_NEXT_OPCODE();
6384 }
6385
6386 ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
6387 {
6388 USE_OPLINE
6389 zval *value;
6390 int result;
6391
6392 if (OP1_TYPE == IS_CV &&
6393 OP2_TYPE == IS_UNUSED &&
6394 (opline->extended_value & ZEND_QUICK_SET)) {
6395 value = EX_VAR(opline->op1.var);
6396 if (opline->extended_value & ZEND_ISSET) {
6397 result =
6398 Z_TYPE_P(value) > IS_NULL &&
6399 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
6400 } else {
6401 SAVE_OPLINE();
6402 result = !i_zend_is_true(value);
6403 if (UNEXPECTED(EG(exception))) {
6404 HANDLE_EXCEPTION();
6405 }
6406 }
6407 ZEND_VM_SMART_BRANCH(result, 0);
6408 ZVAL_BOOL(EX_VAR(opline->result.var), result);
6409 ZEND_VM_SET_NEXT_OPCODE(opline + 1);
6410 ZEND_VM_CONTINUE();
6411 } else {
6412 zend_free_op free_op1;
6413 zval tmp, *varname;
6414
6415 SAVE_OPLINE();
6416 varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
6417 ZVAL_UNDEF(&tmp);
6418 if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
6419 ZVAL_STR(&tmp, zval_get_string(varname));
6420 varname = &tmp;
6421 }
6422
6423 if (OP2_TYPE != IS_UNUSED) {
6424 zend_class_entry *ce;
6425
6426 if (OP2_TYPE == IS_CONST) {
6427 if (OP1_TYPE == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) != NULL)) {
6428 value = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)) + sizeof(void*));
6429
6430
6431 if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
6432 value = NULL;
6433 }
6434
6435 ZEND_VM_C_GOTO(is_var_return);
6436 } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) == NULL)) {
6437 ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
6438 if (UNEXPECTED(ce == NULL)) {
6439 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6440 }
6441 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
6442 }
6443 } else {
6444 ce = Z_CE_P(EX_VAR(opline->op2.var));
6445 if (OP1_TYPE == IS_CONST &&
6446 (value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce)) != NULL) {
6447
6448
6449 if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
6450 value = NULL;
6451 }
6452
6453 ZEND_VM_C_GOTO(is_var_return);
6454 }
6455 }
6456
6457 value = zend_std_get_static_property(ce, Z_STR_P(varname), 1);
6458
6459 if (OP1_TYPE == IS_CONST && value) {
6460 CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce, value);
6461 }
6462 } else {
6463 HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
6464 value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
6465 }
6466
6467 if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
6468 zend_string_release(Z_STR(tmp));
6469 }
6470 FREE_OP1();
6471
6472 ZEND_VM_C_LABEL(is_var_return):
6473 if (opline->extended_value & ZEND_ISSET) {
6474 result = value && Z_TYPE_P(value) > IS_NULL &&
6475 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
6476 } else {
6477 result = !value || !i_zend_is_true(value);
6478 }
6479
6480 ZEND_VM_SMART_BRANCH(result, 1);
6481 ZVAL_BOOL(EX_VAR(opline->result.var), result);
6482 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6483 }
6484 }
6485
6486 ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, CONST|TMPVAR|UNUSED|CV, CONST|TMPVAR|CV)
6487 {
6488 USE_OPLINE
6489 zend_free_op free_op1, free_op2;
6490 zval *container;
6491 int result;
6492 zend_ulong hval;
6493 zval *offset;
6494
6495 SAVE_OPLINE();
6496 container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
6497
6498 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
6499 zend_throw_error(NULL, "Using $this when not in object context");
6500 FREE_UNFETCHED_OP2();
6501 HANDLE_EXCEPTION();
6502 }
6503
6504 offset = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
6505
6506 if (OP1_TYPE != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6507 HashTable *ht;
6508 zval *value;
6509 zend_string *str;
6510
6511 ZEND_VM_C_LABEL(isset_dim_obj_array):
6512 ht = Z_ARRVAL_P(container);
6513 ZEND_VM_C_LABEL(isset_again):
6514 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
6515 str = Z_STR_P(offset);
6516 if (OP2_TYPE != IS_CONST) {
6517 if (ZEND_HANDLE_NUMERIC(str, hval)) {
6518 ZEND_VM_C_GOTO(num_index_prop);
6519 }
6520 }
6521 ZEND_VM_C_LABEL(str_index_prop):
6522 value = zend_hash_find_ind(ht, str);
6523 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
6524 hval = Z_LVAL_P(offset);
6525 ZEND_VM_C_LABEL(num_index_prop):
6526 value = zend_hash_index_find(ht, hval);
6527 } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
6528 offset = Z_REFVAL_P(offset);
6529 ZEND_VM_C_GOTO(isset_again);
6530 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
6531 hval = zend_dval_to_lval(Z_DVAL_P(offset));
6532 ZEND_VM_C_GOTO(num_index_prop);
6533 } else if (Z_TYPE_P(offset) == IS_NULL) {
6534 str = ZSTR_EMPTY_ALLOC();
6535 ZEND_VM_C_GOTO(str_index_prop);
6536 } else if (Z_TYPE_P(offset) == IS_FALSE) {
6537 hval = 0;
6538 ZEND_VM_C_GOTO(num_index_prop);
6539 } else if (Z_TYPE_P(offset) == IS_TRUE) {
6540 hval = 1;
6541 ZEND_VM_C_GOTO(num_index_prop);
6542 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
6543 hval = Z_RES_HANDLE_P(offset);
6544 ZEND_VM_C_GOTO(num_index_prop);
6545 } else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
6546 GET_OP2_UNDEF_CV(offset, BP_VAR_R);
6547 str = ZSTR_EMPTY_ALLOC();
6548 ZEND_VM_C_GOTO(str_index_prop);
6549 } else {
6550 zend_error(E_WARNING, "Illegal offset type in isset or empty");
6551 ZEND_VM_C_GOTO(isset_not_found);
6552 }
6553
6554 if (opline->extended_value & ZEND_ISSET) {
6555
6556 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
6557 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
6558 } else {
6559 result = (value == NULL || !i_zend_is_true(value));
6560 }
6561 ZEND_VM_C_GOTO(isset_dim_obj_exit);
6562 } else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6563 container = Z_REFVAL_P(container);
6564 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6565 ZEND_VM_C_GOTO(isset_dim_obj_array);
6566 }
6567 }
6568
6569 if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
6570 offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R);
6571 }
6572
6573 if (OP1_TYPE == IS_UNUSED ||
6574 (OP1_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_OBJECT))) {
6575 if (EXPECTED(Z_OBJ_HT_P(container)->has_dimension)) {
6576 result =
6577 ((opline->extended_value & ZEND_ISSET) == 0) ^
6578 Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0);
6579 } else {
6580 zend_error(E_NOTICE, "Trying to check element of non-array");
6581 ZEND_VM_C_GOTO(isset_not_found);
6582 }
6583 } else if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) {
6584 zend_long lval;
6585
6586 if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
6587 lval = Z_LVAL_P(offset);
6588 ZEND_VM_C_LABEL(isset_str_offset):
6589 if (EXPECTED(lval >= 0) && (size_t)lval < Z_STRLEN_P(container)) {
6590 if (opline->extended_value & ZEND_ISSET) {
6591 result = 1;
6592 } else {
6593 result = (Z_STRVAL_P(container)[lval] == '0');
6594 }
6595 } else {
6596 ZEND_VM_C_GOTO(isset_not_found);
6597 }
6598 } else {
6599 if (OP2_TYPE & (IS_CV|IS_VAR)) {
6600 ZVAL_DEREF(offset);
6601 }
6602 if (Z_TYPE_P(offset) < IS_STRING
6603 || (Z_TYPE_P(offset) == IS_STRING
6604 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
6605 lval = zval_get_long(offset);
6606 ZEND_VM_C_GOTO(isset_str_offset);
6607 }
6608 ZEND_VM_C_GOTO(isset_not_found);
6609 }
6610 } else {
6611 ZEND_VM_C_LABEL(isset_not_found):
6612 result = ((opline->extended_value & ZEND_ISSET) == 0);
6613 }
6614
6615 ZEND_VM_C_LABEL(isset_dim_obj_exit):
6616 FREE_OP2();
6617 FREE_OP1();
6618 ZEND_VM_SMART_BRANCH(result, 1);
6619 ZVAL_BOOL(EX_VAR(opline->result.var), result);
6620 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6621 }
6622
6623 ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED|CV, CONST|TMPVAR|CV)
6624 {
6625 USE_OPLINE
6626 zend_free_op free_op1, free_op2;
6627 zval *container;
6628 int result;
6629 zval *offset;
6630
6631 SAVE_OPLINE();
6632 container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
6633
6634 if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_OBJ_P(container) == NULL)) {
6635 zend_throw_error(NULL, "Using $this when not in object context");
6636 FREE_UNFETCHED_OP2();
6637 HANDLE_EXCEPTION();
6638 }
6639
6640 offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
6641
6642 if (OP1_TYPE == IS_CONST ||
6643 (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6644 if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6645 container = Z_REFVAL_P(container);
6646 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
6647 ZEND_VM_C_GOTO(isset_no_object);
6648 }
6649 } else {
6650 ZEND_VM_C_GOTO(isset_no_object);
6651 }
6652 }
6653 if (UNEXPECTED(!Z_OBJ_HT_P(container)->has_property)) {
6654 zend_error(E_NOTICE, "Trying to check property of non-object");
6655 ZEND_VM_C_LABEL(isset_no_object):
6656 result = ((opline->extended_value & ZEND_ISSET) == 0);
6657 } else {
6658 result =
6659 ((opline->extended_value & ZEND_ISSET) == 0) ^
6660 Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
6661 }
6662
6663 FREE_OP2();
6664 FREE_OP1();
6665 ZEND_VM_SMART_BRANCH(result, 1);
6666 ZVAL_BOOL(EX_VAR(opline->result.var), result);
6667 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6668 }
6669
6670 ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMPVAR|UNUSED|CV, ANY)
6671 {
6672 USE_OPLINE
6673
6674 SAVE_OPLINE();
6675 if (OP1_TYPE != IS_UNUSED) {
6676 zend_free_op free_op1;
6677 zval *ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
6678
6679 do {
6680 if (Z_TYPE_P(ptr) == IS_LONG) {
6681 EG(exit_status) = Z_LVAL_P(ptr);
6682 } else {
6683 if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(ptr)) {
6684 ptr = Z_REFVAL_P(ptr);
6685 if (Z_TYPE_P(ptr) == IS_LONG) {
6686 EG(exit_status) = Z_LVAL_P(ptr);
6687 break;
6688 }
6689 }
6690 zend_print_variable(ptr);
6691 }
6692 } while (0);
6693 FREE_OP1();
6694 }
6695 zend_bailout();
6696 ZEND_VM_NEXT_OPCODE();
6697 }
6698
6699 ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY)
6700 {
6701 USE_OPLINE
6702
6703 ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting));
6704
6705 if (EG(error_reporting)) {
6706 do {
6707 EG(error_reporting) = 0;
6708 if (!EG(error_reporting_ini_entry)) {
6709 zend_ini_entry *p = zend_hash_str_find_ptr(EG(ini_directives), "error_reporting", sizeof("error_reporting")-1);
6710 if (p) {
6711 EG(error_reporting_ini_entry) = p;
6712 } else {
6713 break;
6714 }
6715 }
6716 if (!EG(error_reporting_ini_entry)->modified) {
6717 if (!EG(modified_ini_directives)) {
6718 ALLOC_HASHTABLE(EG(modified_ini_directives));
6719 zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
6720 }
6721 if (EXPECTED(zend_hash_str_add_ptr(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting")-1, EG(error_reporting_ini_entry)) != NULL)) {
6722 EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
6723 EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
6724 EG(error_reporting_ini_entry)->modified = 1;
6725 }
6726 }
6727 } while (0);
6728 }
6729 ZEND_VM_NEXT_OPCODE();
6730 }
6731
6732 ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY)
6733 {
6734 USE_OPLINE
6735
6736 if (!EG(error_reporting) && Z_LVAL_P(EX_VAR(opline->op1.var)) != 0) {
6737 EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var));
6738 }
6739 ZEND_VM_NEXT_OPCODE();
6740 }
6741
6742 ZEND_VM_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, ANY)
6743 {
6744 USE_OPLINE
6745 zend_free_op free_op1;
6746 zval *value;
6747 zval *ref = NULL;
6748
6749 SAVE_OPLINE();
6750 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
6751
6752 if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && Z_ISREF_P(value)) {
6753 if (OP1_TYPE == IS_VAR) {
6754 ref = value;
6755 }
6756 value = Z_REFVAL_P(value);
6757 }
6758 if (i_zend_is_true(value)) {
6759 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
6760 if (OP1_TYPE == IS_CONST) {
6761 if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
6762 zval_copy_ctor_func(EX_VAR(opline->result.var));
6763 }
6764 } else if (OP1_TYPE == IS_CV) {
6765 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
6766 } else if (OP1_TYPE == IS_VAR && ref) {
6767 zend_reference *r = Z_REF_P(ref);
6768
6769 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
6770 if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
6771 efree_size(r, sizeof(zend_reference));
6772 }
6773 }
6774 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
6775 }
6776
6777 FREE_OP1();
6778 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6779 }
6780
6781 ZEND_VM_HANDLER(169, ZEND_COALESCE, CONST|TMP|VAR|CV, ANY)
6782 {
6783 USE_OPLINE
6784 zend_free_op free_op1;
6785 zval *value;
6786 zval *ref = NULL;
6787
6788 SAVE_OPLINE();
6789 value = GET_OP1_ZVAL_PTR(BP_VAR_IS);
6790
6791 if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && Z_ISREF_P(value)) {
6792 if (OP1_TYPE == IS_VAR) {
6793 ref = value;
6794 }
6795 value = Z_REFVAL_P(value);
6796 }
6797
6798 if (Z_TYPE_P(value) > IS_NULL) {
6799 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
6800 if (OP1_TYPE == IS_CONST) {
6801 if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
6802 zval_copy_ctor_func(EX_VAR(opline->result.var));
6803 }
6804 } else if (OP1_TYPE == IS_CV) {
6805 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
6806 } else if (OP1_TYPE == IS_VAR && ref) {
6807 zend_reference *r = Z_REF_P(ref);
6808
6809 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
6810 if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
6811 efree_size(r, sizeof(zend_reference));
6812 }
6813 }
6814 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
6815 }
6816
6817 FREE_OP1();
6818 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6819 }
6820
6821 ZEND_VM_HANDLER(22, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY)
6822 {
6823 USE_OPLINE
6824 zend_free_op free_op1;
6825 zval *value;
6826
6827 value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
6828 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
6829 SAVE_OPLINE();
6830 GET_OP1_UNDEF_CV(value, BP_VAR_R);
6831 ZVAL_NULL(EX_VAR(opline->result.var));
6832 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6833 }
6834
6835 if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && Z_ISREF_P(value)) {
6836 ZVAL_COPY(EX_VAR(opline->result.var), Z_REFVAL_P(value));
6837 if (OP1_TYPE == IS_VAR) {
6838 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
6839 efree_size(Z_REF_P(value), sizeof(zend_reference));
6840 }
6841 }
6842 } else {
6843 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
6844 if (OP1_TYPE == IS_CONST) {
6845 if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
6846 zval_copy_ctor_func(EX_VAR(opline->result.var));
6847 }
6848 } else if (OP1_TYPE == IS_CV) {
6849 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
6850 }
6851 }
6852 ZEND_VM_NEXT_OPCODE();
6853 }
6854
6855 ZEND_VM_HANDLER(101, ZEND_EXT_STMT, ANY, ANY)
6856 {
6857 USE_OPLINE
6858
6859 if (!EG(no_extensions)) {
6860 SAVE_OPLINE();
6861 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, EX(func));
6862 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6863 }
6864 ZEND_VM_NEXT_OPCODE();
6865 }
6866
6867 ZEND_VM_HANDLER(102, ZEND_EXT_FCALL_BEGIN, ANY, ANY)
6868 {
6869 USE_OPLINE
6870
6871 if (!EG(no_extensions)) {
6872 SAVE_OPLINE();
6873 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, EX(func));
6874 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6875 }
6876 ZEND_VM_NEXT_OPCODE();
6877 }
6878
6879 ZEND_VM_HANDLER(103, ZEND_EXT_FCALL_END, ANY, ANY)
6880 {
6881 USE_OPLINE
6882
6883 if (!EG(no_extensions)) {
6884 SAVE_OPLINE();
6885 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, EX(func));
6886 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6887 }
6888 ZEND_VM_NEXT_OPCODE();
6889 }
6890
6891 ZEND_VM_HANDLER(139, ZEND_DECLARE_CLASS, ANY, ANY)
6892 {
6893 USE_OPLINE
6894
6895 SAVE_OPLINE();
6896 Z_CE_P(EX_VAR(opline->result.var)) = do_bind_class(&EX(func)->op_array, opline, EG(class_table), 0);
6897 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6898 }
6899
6900 ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, ANY)
6901 {
6902 USE_OPLINE
6903
6904 SAVE_OPLINE();
6905 Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0);
6906 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6907 }
6908
6909 ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, ANY, ANY)
6910 {
6911 USE_OPLINE
6912 zval *zce, *orig_zce;
6913
6914 SAVE_OPLINE();
6915 if ((zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)))) == NULL ||
6916 ((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)))) != NULL &&
6917 Z_CE_P(zce) != Z_CE_P(orig_zce))) {
6918 do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0);
6919 }
6920 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6921 }
6922
6923 ZEND_VM_HANDLER(171, ZEND_DECLARE_ANON_CLASS, ANY, ANY)
6924 {
6925 zend_class_entry *ce;
6926 USE_OPLINE
6927
6928 SAVE_OPLINE();
6929 ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)));
6930 Z_CE_P(EX_VAR(opline->result.var)) = ce;
6931 ZEND_ASSERT(ce != NULL);
6932
6933 if (ce->ce_flags & ZEND_ACC_ANON_BOUND) {
6934 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op1));
6935 }
6936
6937 if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
6938 zend_verify_abstract_class(ce);
6939 }
6940 ce->ce_flags |= ZEND_ACC_ANON_BOUND;
6941 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6942 }
6943
6944 ZEND_VM_HANDLER(172, ZEND_DECLARE_ANON_INHERITED_CLASS, ANY, ANY)
6945 {
6946 zend_class_entry *ce;
6947 USE_OPLINE
6948
6949 SAVE_OPLINE();
6950 ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)));
6951 Z_CE_P(EX_VAR(opline->result.var)) = ce;
6952 ZEND_ASSERT(ce != NULL);
6953
6954 if (ce->ce_flags & ZEND_ACC_ANON_BOUND) {
6955 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op1));
6956 }
6957
6958 zend_do_inheritance(ce, Z_CE_P(EX_VAR(opline->extended_value)));
6959 ce->ce_flags |= ZEND_ACC_ANON_BOUND;
6960 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6961 }
6962
6963 ZEND_VM_HANDLER(141, ZEND_DECLARE_FUNCTION, ANY, ANY)
6964 {
6965 USE_OPLINE
6966
6967 SAVE_OPLINE();
6968 do_bind_function(&EX(func)->op_array, opline, EG(function_table), 0);
6969 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6970 }
6971
6972 ZEND_VM_HANDLER(105, ZEND_TICKS, ANY, ANY)
6973 {
6974 USE_OPLINE
6975
6976 if ((uint32_t)++EG(ticks_count) >= opline->extended_value) {
6977 EG(ticks_count) = 0;
6978 if (zend_ticks_function) {
6979 SAVE_OPLINE();
6980 zend_ticks_function(opline->extended_value);
6981 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6982 }
6983 }
6984 ZEND_VM_NEXT_OPCODE();
6985 }
6986
6987 ZEND_VM_HANDLER(138, ZEND_INSTANCEOF, TMPVAR|CV, CONST|VAR)
6988 {
6989 USE_OPLINE
6990 zend_free_op free_op1;
6991 zval *expr;
6992 zend_bool result;
6993
6994 SAVE_OPLINE();
6995 expr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
6996
6997 ZEND_VM_C_LABEL(try_instanceof):
6998 if (Z_TYPE_P(expr) == IS_OBJECT) {
6999 zend_class_entry *ce;
7000
7001 if (OP2_TYPE == IS_CONST) {
7002 ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
7003 if (UNEXPECTED(ce == NULL)) {
7004 ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
7005 if (UNEXPECTED(ce == NULL)) {
7006 ZVAL_FALSE(EX_VAR(opline->result.var));
7007 FREE_OP1();
7008 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7009 }
7010 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
7011 }
7012 } else {
7013 ce = Z_CE_P(EX_VAR(opline->op2.var));
7014 }
7015 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
7016 } else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
7017 expr = Z_REFVAL_P(expr);
7018 ZEND_VM_C_GOTO(try_instanceof);
7019 } else {
7020 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
7021 GET_OP1_UNDEF_CV(expr, BP_VAR_R);
7022 }
7023 result = 0;
7024 }
7025 FREE_OP1();
7026 ZEND_VM_SMART_BRANCH(result, 1);
7027 ZVAL_BOOL(EX_VAR(opline->result.var), result);
7028 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7029 }
7030
7031 ZEND_VM_HANDLER(104, ZEND_EXT_NOP, ANY, ANY)
7032 {
7033 USE_OPLINE
7034
7035 ZEND_VM_NEXT_OPCODE();
7036 }
7037
7038 ZEND_VM_HANDLER(0, ZEND_NOP, ANY, ANY)
7039 {
7040 USE_OPLINE
7041
7042 ZEND_VM_NEXT_OPCODE();
7043 }
7044
7045 ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST)
7046 {
7047 USE_OPLINE
7048 zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
7049 zend_class_entry *iface;
7050
7051 SAVE_OPLINE();
7052 iface = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
7053 if (UNEXPECTED(iface == NULL)) {
7054 iface = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_INTERFACE);
7055 if (UNEXPECTED(iface == NULL)) {
7056 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7057 }
7058 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), iface);
7059 }
7060
7061 if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
7062 zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ZSTR_VAL(ce->name), ZSTR_VAL(iface->name));
7063 }
7064 zend_do_implement_interface(ce, iface);
7065
7066 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7067 }
7068
7069 ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY)
7070 {
7071 USE_OPLINE
7072 zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
7073 zend_class_entry *trait;
7074
7075 SAVE_OPLINE();
7076 trait = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
7077 if (UNEXPECTED(trait == NULL)) {
7078 trait = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)),
7079 EX_CONSTANT(opline->op2) + 1,
7080 ZEND_FETCH_CLASS_TRAIT);
7081 if (UNEXPECTED(trait == NULL)) {
7082 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7083 }
7084 if (!(trait->ce_flags & ZEND_ACC_TRAIT)) {
7085 zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ZSTR_VAL(ce->name), ZSTR_VAL(trait->name));
7086 }
7087 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), trait);
7088 }
7089
7090 zend_do_implement_trait(ce, trait);
7091
7092 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7093 }
7094
7095 ZEND_VM_HANDLER(155, ZEND_BIND_TRAITS, ANY, ANY)
7096 {
7097 USE_OPLINE
7098 zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
7099
7100 SAVE_OPLINE();
7101 zend_do_bind_traits(ce);
7102 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7103 }
7104
7105 ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
7106 {
7107 uint32_t op_num = EG(opline_before_exception) - EX(func)->op_array.opcodes;
7108 int i;
7109 uint32_t catch_op_num = 0, finally_op_num = 0, finally_op_end = 0;
7110 int in_finally = 0;
7111
7112 ZEND_VM_INTERRUPT_CHECK();
7113
7114 {
7115 const zend_op *exc_opline = EG(opline_before_exception);
7116 if ((exc_opline->opcode == ZEND_FREE || exc_opline->opcode == ZEND_FE_FREE)
7117 && exc_opline->extended_value & ZEND_FREE_ON_RETURN) {
7118
7119
7120
7121
7122 op_num = EX(func)->op_array.brk_cont_array[exc_opline->op2.num].brk;
7123 }
7124 }
7125
7126 for (i = 0; i < EX(func)->op_array.last_try_catch; i++) {
7127 if (EX(func)->op_array.try_catch_array[i].try_op > op_num) {
7128
7129 break;
7130 }
7131 in_finally = 0;
7132 if (op_num < EX(func)->op_array.try_catch_array[i].catch_op) {
7133 catch_op_num = EX(func)->op_array.try_catch_array[i].catch_op;
7134 }
7135 if (op_num < EX(func)->op_array.try_catch_array[i].finally_op) {
7136 finally_op_num = EX(func)->op_array.try_catch_array[i].finally_op;
7137 finally_op_end = EX(func)->op_array.try_catch_array[i].finally_end;
7138 }
7139 if (op_num >= EX(func)->op_array.try_catch_array[i].finally_op &&
7140 op_num < EX(func)->op_array.try_catch_array[i].finally_end) {
7141 finally_op_end = EX(func)->op_array.try_catch_array[i].finally_end;
7142 in_finally = 1;
7143 }
7144 }
7145
7146 cleanup_unfinished_calls(execute_data, op_num);
7147
7148 if (finally_op_num && (!catch_op_num || catch_op_num >= finally_op_num)) {
7149 zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[finally_op_end].op1.var);
7150
7151 cleanup_live_vars(execute_data, op_num, finally_op_num);
7152 if (in_finally && Z_OBJ_P(fast_call)) {
7153 zend_exception_set_previous(EG(exception), Z_OBJ_P(fast_call));
7154 }
7155 Z_OBJ_P(fast_call) = EG(exception);
7156 EG(exception) = NULL;
7157 fast_call->u2.lineno = (uint32_t)-1;
7158 ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[finally_op_num]);
7159 ZEND_VM_CONTINUE();
7160 } else {
7161 cleanup_live_vars(execute_data, op_num, catch_op_num);
7162 if (in_finally) {
7163
7164 zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[finally_op_end].op1.var);
7165
7166 if (Z_OBJ_P(fast_call)) {
7167 zend_exception_set_previous(EG(exception), Z_OBJ_P(fast_call));
7168 Z_OBJ_P(fast_call) = NULL;
7169 }
7170 }
7171 if (catch_op_num) {
7172 ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[catch_op_num]);
7173 ZEND_VM_CONTINUE();
7174 } else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_GENERATOR) != 0)) {
7175 zend_generator *generator = zend_get_running_generator(execute_data);
7176 zend_generator_close(generator, 1);
7177 ZEND_VM_RETURN();
7178 } else {
7179 ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
7180 }
7181 }
7182 }
7183
7184 ZEND_VM_HANDLER(146, ZEND_VERIFY_ABSTRACT_CLASS, ANY, ANY)
7185 {
7186 USE_OPLINE
7187
7188 SAVE_OPLINE();
7189 zend_verify_abstract_class(Z_CE_P(EX_VAR(opline->op1.var)));
7190 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7191 }
7192
7193 ZEND_VM_HANDLER(150, ZEND_USER_OPCODE, ANY, ANY)
7194 {
7195 USE_OPLINE
7196 int ret;
7197
7198 SAVE_OPLINE();
7199 ret = zend_user_opcode_handlers[opline->opcode](execute_data);
7200 opline = EX(opline);
7201
7202 switch (ret) {
7203 case ZEND_USER_OPCODE_CONTINUE:
7204 ZEND_VM_CONTINUE();
7205 case ZEND_USER_OPCODE_RETURN:
7206 if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_GENERATOR) != 0)) {
7207 zend_generator *generator = zend_get_running_generator(execute_data);
7208 zend_generator_close(generator, 1);
7209 ZEND_VM_RETURN();
7210 } else {
7211 ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
7212 }
7213 case ZEND_USER_OPCODE_ENTER:
7214 ZEND_VM_ENTER();
7215 case ZEND_USER_OPCODE_LEAVE:
7216 ZEND_VM_LEAVE();
7217 case ZEND_USER_OPCODE_DISPATCH:
7218 ZEND_VM_DISPATCH(opline->opcode, opline);
7219 default:
7220 ZEND_VM_DISPATCH((zend_uchar)(ret & 0xff), opline);
7221 }
7222 }
7223
7224 ZEND_VM_HANDLER(143, ZEND_DECLARE_CONST, CONST, CONST)
7225 {
7226 USE_OPLINE
7227 zend_free_op free_op1, free_op2;
7228 zval *name;
7229 zval *val;
7230 zend_constant c;
7231
7232 SAVE_OPLINE();
7233 name = GET_OP1_ZVAL_PTR(BP_VAR_R);
7234 val = GET_OP2_ZVAL_PTR(BP_VAR_R);
7235
7236 ZVAL_COPY_VALUE(&c.value, val);
7237 if (Z_OPT_CONSTANT(c.value)) {
7238 if (UNEXPECTED(zval_update_constant_ex(&c.value, 0, NULL) != SUCCESS)) {
7239 FREE_OP1();
7240 FREE_OP2();
7241 HANDLE_EXCEPTION();
7242 }
7243 } else {
7244
7245 if (UNEXPECTED(Z_OPT_COPYABLE(c.value))) {
7246 zval_copy_ctor_func(&c.value);
7247 }
7248 }
7249 c.flags = CONST_CS;
7250 c.name = zend_string_dup(Z_STR_P(name), 0);
7251 c.module_number = PHP_USER_CONSTANT;
7252
7253 if (zend_register_constant(&c) == FAILURE) {
7254 }
7255
7256 FREE_OP1();
7257 FREE_OP2();
7258 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7259 }
7260
7261 ZEND_VM_HANDLER(153, ZEND_DECLARE_LAMBDA_FUNCTION, CONST, UNUSED)
7262 {
7263 USE_OPLINE
7264 zval *zfunc;
7265
7266 SAVE_OPLINE();
7267
7268 zfunc = zend_hash_find(EG(function_table), Z_STR_P(EX_CONSTANT(opline->op1)));
7269 ZEND_ASSERT(zfunc != NULL && Z_FUNC_P(zfunc)->type == ZEND_USER_FUNCTION);
7270
7271 if (UNEXPECTED((Z_FUNC_P(zfunc)->common.fn_flags & ZEND_ACC_STATIC) ||
7272 (EX(func)->common.fn_flags & ZEND_ACC_STATIC))) {
7273 zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc),
7274 EG(scope), EX(called_scope), NULL);
7275 } else {
7276 zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc),
7277 EG(scope), EX(called_scope), Z_OBJ(EX(This)) ? &EX(This) : NULL);
7278 }
7279
7280 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7281 }
7282
7283 ZEND_VM_HANDLER(156, ZEND_SEPARATE, VAR, UNUSED)
7284 {
7285 USE_OPLINE
7286 zval *var_ptr;
7287
7288 var_ptr = EX_VAR(opline->op1.var);
7289 if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
7290 if (UNEXPECTED(Z_REFCOUNT_P(var_ptr) == 1)) {
7291 ZVAL_UNREF(var_ptr);
7292 }
7293 } else if (Z_COPYABLE_P(var_ptr) && Z_REFCOUNT_P(var_ptr) > 1) {
7294 Z_DELREF_P(var_ptr);
7295 ZVAL_DUP(EX_VAR(opline->op1.var), var_ptr);
7296 }
7297 ZEND_VM_NEXT_OPCODE();
7298 }
7299
7300 ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSED)
7301 {
7302 USE_OPLINE
7303
7304 zend_generator *generator = zend_get_running_generator(execute_data);
7305
7306 SAVE_OPLINE();
7307 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
7308 zend_throw_error(NULL, "Cannot yield from finally in a force-closed generator");
7309 FREE_UNFETCHED_OP2();
7310 FREE_UNFETCHED_OP1();
7311 HANDLE_EXCEPTION();
7312 }
7313
7314
7315 zval_ptr_dtor(&generator->value);
7316
7317
7318 zval_ptr_dtor(&generator->key);
7319
7320
7321 if (OP1_TYPE != IS_UNUSED) {
7322 zend_free_op free_op1;
7323
7324 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
7325
7326
7327 if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
7328 zval *value;
7329
7330 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
7331
7332 value = GET_OP1_ZVAL_PTR(BP_VAR_R);
7333 ZVAL_COPY_VALUE(&generator->value, value);
7334 if (OP1_TYPE == IS_CONST) {
7335 if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
7336 zval_copy_ctor_func(&generator->value);
7337 }
7338 }
7339 } else {
7340 zval *value_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
7341
7342 if (OP1_TYPE == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
7343 zend_throw_error(NULL, "Cannot yield string offsets by reference");
7344 FREE_UNFETCHED_OP2();
7345 HANDLE_EXCEPTION();
7346 }
7347
7348
7349
7350 if (OP1_TYPE == IS_VAR &&
7351 (value_ptr == &EG(uninitialized_zval) ||
7352 (opline->extended_value == ZEND_RETURNS_FUNCTION &&
7353 !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) {
7354 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
7355 } else {
7356 ZVAL_MAKE_REF(value_ptr);
7357 }
7358 ZVAL_COPY(&generator->value, value_ptr);
7359
7360 FREE_OP1_VAR_PTR();
7361 }
7362 } else {
7363 zval *value = GET_OP1_ZVAL_PTR(BP_VAR_R);
7364
7365
7366 if (OP1_TYPE == IS_CONST) {
7367 ZVAL_COPY_VALUE(&generator->value, value);
7368 if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
7369 zval_copy_ctor_func(&generator->value);
7370 }
7371 } else if (OP1_TYPE == IS_TMP_VAR) {
7372 ZVAL_COPY_VALUE(&generator->value, value);
7373 } else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
7374 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
7375 FREE_OP1_IF_VAR();
7376 } else {
7377 ZVAL_COPY_VALUE(&generator->value, value);
7378 if (OP1_TYPE == IS_CV) {
7379 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
7380 }
7381 }
7382 }
7383 } else {
7384
7385 ZVAL_NULL(&generator->value);
7386 }
7387
7388
7389 if (OP2_TYPE != IS_UNUSED) {
7390 zend_free_op free_op2;
7391 zval *key = GET_OP2_ZVAL_PTR(BP_VAR_R);
7392
7393
7394 if (OP2_TYPE == IS_CONST) {
7395 ZVAL_COPY_VALUE(&generator->key, key);
7396 if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
7397 zval_copy_ctor_func(&generator->key);
7398 }
7399 } else if (OP2_TYPE == IS_TMP_VAR) {
7400 ZVAL_COPY_VALUE(&generator->key, key);
7401 } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
7402 ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
7403 FREE_OP2_IF_VAR();
7404 } else {
7405 ZVAL_COPY_VALUE(&generator->key, key);
7406 if (OP2_TYPE == IS_CV) {
7407 if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
7408 }
7409 }
7410
7411 if (Z_TYPE(generator->key) == IS_LONG
7412 && Z_LVAL(generator->key) > generator->largest_used_integer_key
7413 ) {
7414 generator->largest_used_integer_key = Z_LVAL(generator->key);
7415 }
7416 } else {
7417
7418 generator->largest_used_integer_key++;
7419 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
7420 }
7421
7422 if (RETURN_VALUE_USED(opline)) {
7423
7424
7425 generator->send_target = EX_VAR(opline->result.var);
7426 ZVAL_NULL(generator->send_target);
7427 } else {
7428 generator->send_target = NULL;
7429 }
7430
7431
7432
7433 ZEND_VM_INC_OPCODE();
7434
7435
7436
7437 SAVE_OPLINE();
7438
7439 ZEND_VM_RETURN();
7440 }
7441
7442 ZEND_VM_HANDLER(142, ZEND_YIELD_FROM, CONST|TMP|VAR|CV, ANY)
7443 {
7444 USE_OPLINE
7445
7446 zend_generator *generator = zend_get_running_generator(execute_data);
7447
7448 zval *val;
7449 zend_free_op free_op1;
7450
7451 SAVE_OPLINE();
7452 val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
7453
7454 if (Z_TYPE_P(val) == IS_ARRAY) {
7455 ZVAL_COPY_VALUE(&generator->values, val);
7456 if (OP1_TYPE != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(val)) {
7457 Z_ADDREF_P(val);
7458 }
7459 Z_FE_POS(generator->values) = 0;
7460
7461 FREE_OP1_IF_VAR();
7462 } else if (OP1_TYPE != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
7463 zend_class_entry *ce = Z_OBJCE_P(val);
7464 if (ce == zend_ce_generator) {
7465 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
7466
7467 if (OP1_TYPE != IS_TMP_VAR) {
7468 Z_ADDREF_P(val);
7469 }
7470 FREE_OP1_IF_VAR();
7471
7472 if (Z_ISUNDEF(new_gen->retval)) {
7473 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
7474 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
7475 HANDLE_EXCEPTION();
7476 } else {
7477 zend_generator_yield_from(generator, new_gen);
7478 }
7479 } else if (UNEXPECTED(new_gen->execute_data == NULL)) {
7480 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
7481 HANDLE_EXCEPTION();
7482 } else {
7483 if (RETURN_VALUE_USED(opline)) {
7484 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
7485 }
7486 ZEND_VM_NEXT_OPCODE();
7487 }
7488 } else {
7489 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
7490 FREE_OP1();
7491
7492 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
7493 if (!EG(exception)) {
7494 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
7495 }
7496 HANDLE_EXCEPTION();
7497 }
7498
7499 iter->index = 0;
7500 if (iter->funcs->rewind) {
7501 iter->funcs->rewind(iter);
7502 if (UNEXPECTED(EG(exception) != NULL)) {
7503 OBJ_RELEASE(&iter->std);
7504 HANDLE_EXCEPTION();
7505 }
7506 }
7507
7508 ZVAL_OBJ(&generator->values, &iter->std);
7509 }
7510 } else {
7511 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables", 0);
7512 HANDLE_EXCEPTION();
7513 }
7514
7515
7516
7517 if (RETURN_VALUE_USED(opline)) {
7518 ZVAL_NULL(EX_VAR(opline->result.var));
7519 }
7520
7521
7522 generator->send_target = NULL;
7523
7524
7525
7526 ZEND_VM_INC_OPCODE();
7527
7528
7529
7530 SAVE_OPLINE();
7531
7532 ZEND_VM_RETURN();
7533 }
7534
7535 ZEND_VM_HANDLER(159, ZEND_DISCARD_EXCEPTION, ANY, ANY)
7536 {
7537 USE_OPLINE
7538 zval *fast_call = EX_VAR(opline->op1.var);
7539
7540
7541 if (Z_OBJ_P(fast_call) != NULL) {
7542 SAVE_OPLINE();
7543
7544 OBJ_RELEASE(Z_OBJ_P(fast_call));
7545 Z_OBJ_P(fast_call) = NULL;
7546 }
7547
7548 ZEND_VM_NEXT_OPCODE();
7549 }
7550
7551 ZEND_VM_HANDLER(162, ZEND_FAST_CALL, ANY, ANY)
7552 {
7553 USE_OPLINE
7554 zval *fast_call = EX_VAR(opline->result.var);
7555
7556 if (opline->extended_value == ZEND_FAST_CALL_FROM_FINALLY && UNEXPECTED(Z_OBJ_P(fast_call) != NULL)) {
7557 fast_call->u2.lineno = (uint32_t)-1;
7558 } else {
7559 Z_OBJ_P(fast_call) = NULL;
7560
7561 fast_call->u2.lineno = opline - EX(func)->op_array.opcodes;
7562 }
7563 ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op1));
7564 ZEND_VM_CONTINUE();
7565 }
7566
7567 ZEND_VM_HANDLER(163, ZEND_FAST_RET, ANY, ANY)
7568 {
7569 USE_OPLINE
7570 zval *fast_call = EX_VAR(opline->op1.var);
7571
7572 if (fast_call->u2.lineno != (uint32_t)-1) {
7573 const zend_op *fast_ret = EX(func)->op_array.opcodes + fast_call->u2.lineno;
7574 ZEND_VM_SET_OPCODE(fast_ret + 1);
7575 if (fast_ret->extended_value & ZEND_FAST_CALL_FROM_FINALLY) {
7576 fast_call->u2.lineno = fast_ret->op2.opline_num;
7577 }
7578 ZEND_VM_CONTINUE();
7579 } else {
7580
7581 USE_OPLINE
7582
7583 if (opline->extended_value == ZEND_FAST_RET_TO_FINALLY) {
7584 cleanup_live_vars(execute_data, opline - EX(func)->op_array.opcodes, opline->op2.opline_num);
7585 ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->op2.opline_num]);
7586 ZEND_VM_CONTINUE();
7587 } else {
7588 EG(exception) = Z_OBJ_P(fast_call);
7589 Z_OBJ_P(fast_call) = NULL;
7590 if (opline->extended_value == ZEND_FAST_RET_TO_CATCH) {
7591 cleanup_live_vars(execute_data, opline - EX(func)->op_array.opcodes, opline->op2.opline_num);
7592 ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->op2.opline_num]);
7593 ZEND_VM_CONTINUE();
7594 } else {
7595 cleanup_live_vars(execute_data, opline - EX(func)->op_array.opcodes, 0);
7596 if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_GENERATOR) != 0)) {
7597 zend_generator *generator = zend_get_running_generator(execute_data);
7598 zend_generator_close(generator, 1);
7599 ZEND_VM_RETURN();
7600 } else {
7601 ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
7602 }
7603 }
7604 }
7605 }
7606 }
7607
7608 ZEND_VM_HANDLER(168, ZEND_BIND_GLOBAL, CV, CONST)
7609 {
7610 USE_OPLINE
7611 zend_free_op free_op1, free_op2;
7612 zval *varname;
7613 zval *value;
7614 zval *variable_ptr;
7615 uint32_t idx;
7616
7617 ZEND_VM_REPEATABLE_OPCODE
7618
7619 varname = GET_OP2_ZVAL_PTR(BP_VAR_R);
7620
7621
7622 idx = (uint32_t)(uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(varname)) - 1;
7623 if (EXPECTED(idx < EG(symbol_table).nNumUsed)) {
7624 Bucket *p = EG(symbol_table).arData + idx;
7625
7626 if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
7627 (EXPECTED(p->key == Z_STR_P(varname)) ||
7628 (EXPECTED(p->h == ZSTR_H(Z_STR_P(varname))) &&
7629 EXPECTED(p->key != NULL) &&
7630 EXPECTED(ZSTR_LEN(p->key) == Z_STRLEN_P(varname)) &&
7631 EXPECTED(memcmp(ZSTR_VAL(p->key), Z_STRVAL_P(varname), Z_STRLEN_P(varname)) == 0)))) {
7632
7633 value = &EG(symbol_table).arData[idx].val;
7634 ZEND_VM_C_GOTO(check_indirect);
7635 }
7636 }
7637
7638 value = zend_hash_find(&EG(symbol_table), Z_STR_P(varname));
7639 if (UNEXPECTED(value == NULL)) {
7640 value = zend_hash_add_new(&EG(symbol_table), Z_STR_P(varname), &EG(uninitialized_zval));
7641 idx = ((char*)value - (char*)EG(symbol_table).arData) / sizeof(Bucket);
7642
7643 CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(uintptr_t)(idx + 1));
7644 } else {
7645 idx = ((char*)value - (char*)EG(symbol_table).arData) / sizeof(Bucket);
7646
7647 CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(uintptr_t)(idx + 1));
7648 ZEND_VM_C_LABEL(check_indirect):
7649
7650 if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
7651 value = Z_INDIRECT_P(value);
7652 if (UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
7653 ZVAL_NULL(value);
7654 }
7655 }
7656 }
7657
7658 do {
7659 zend_reference *ref;
7660
7661 if (UNEXPECTED(!Z_ISREF_P(value))) {
7662 ref = (zend_reference*)emalloc(sizeof(zend_reference));
7663 GC_REFCOUNT(ref) = 2;
7664 GC_TYPE_INFO(ref) = IS_REFERENCE;
7665 ZVAL_COPY_VALUE(&ref->val, value);
7666 Z_REF_P(value) = ref;
7667 Z_TYPE_INFO_P(value) = IS_REFERENCE_EX;
7668 } else {
7669 ref = Z_REF_P(value);
7670 GC_REFCOUNT(ref)++;
7671 }
7672
7673 variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
7674
7675 if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
7676 uint32_t refcnt = Z_DELREF_P(variable_ptr);
7677
7678 if (UNEXPECTED(variable_ptr == value)) {
7679 break;
7680 }
7681 if (refcnt == 0) {
7682 SAVE_OPLINE();
7683 zval_dtor_func_for_ptr(Z_COUNTED_P(variable_ptr));
7684 if (UNEXPECTED(EG(exception))) {
7685 ZVAL_NULL(variable_ptr);
7686 HANDLE_EXCEPTION();
7687 }
7688 } else {
7689 GC_ZVAL_CHECK_POSSIBLE_ROOT(variable_ptr);
7690 }
7691 }
7692 ZVAL_REF(variable_ptr, ref);
7693 } while (0);
7694
7695 ZEND_VM_REPEAT_OPCODE(ZEND_BIND_GLOBAL);
7696 ZEND_VM_NEXT_OPCODE();
7697 }
7698
7699 ZEND_VM_HANDLER(121, ZEND_STRLEN, CONST|TMPVAR|CV, ANY)
7700 {
7701 USE_OPLINE
7702 zval *value;
7703 zend_free_op free_op1;
7704
7705 SAVE_OPLINE();
7706 value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
7707 ZEND_VM_C_LABEL(try_strlen):
7708 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
7709 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
7710 } else {
7711 zend_bool strict;
7712
7713 if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
7714 value = GET_OP1_UNDEF_CV(value, BP_VAR_R);
7715 }
7716 if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
7717 value = Z_REFVAL_P(value);
7718 ZEND_VM_C_GOTO(try_strlen);
7719 }
7720 strict = EX_USES_STRICT_TYPES();
7721 do {
7722 if (EXPECTED(!strict)) {
7723 zend_string *str;
7724 zval tmp;
7725
7726 ZVAL_COPY(&tmp, value);
7727 if (zend_parse_arg_str_weak(&tmp, &str)) {
7728 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
7729 zval_ptr_dtor(&tmp);
7730 break;
7731 }
7732 zval_ptr_dtor(&tmp);
7733 }
7734 zend_internal_type_error(strict, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
7735 ZVAL_NULL(EX_VAR(opline->result.var));
7736 } while (0);
7737 }
7738 FREE_OP1();
7739 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7740 }
7741
7742 ZEND_VM_HANDLER(123, ZEND_TYPE_CHECK, CONST|TMP|VAR|CV, ANY)
7743 {
7744 USE_OPLINE
7745 zval *value;
7746 int result = 0;
7747 zend_free_op free_op1;
7748
7749 SAVE_OPLINE();
7750 value = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
7751 if (EXPECTED(Z_TYPE_P(value) == opline->extended_value)) {
7752 if (OP1_TYPE != IS_CONST && UNEXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
7753 zend_class_entry *ce = Z_OBJCE_P(value);
7754
7755 if (UNEXPECTED(ZSTR_LEN(ce->name) != sizeof("__PHP_Incomplete_Class") - 1) ||
7756 EXPECTED(memcmp(ZSTR_VAL(ce->name), "__PHP_Incomplete_Class", sizeof("__PHP_Incomplete_Class") - 1) != 0)) {
7757 result = 1;
7758 }
7759 } else if (UNEXPECTED(Z_TYPE_P(value) == IS_RESOURCE)) {
7760 const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(value));
7761
7762 if (EXPECTED(type_name != NULL)) {
7763 result = 1;
7764 }
7765 } else {
7766 result = 1;
7767 }
7768 } else if (UNEXPECTED(opline->extended_value == _IS_BOOL) &&
7769 EXPECTED(Z_TYPE_P(value) == IS_TRUE || Z_TYPE_P(value) == IS_FALSE)) {
7770 result = 1;
7771 }
7772 FREE_OP1();
7773 ZEND_VM_SMART_BRANCH(result, 1);
7774 ZVAL_BOOL(EX_VAR(opline->result.var), result);
7775 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7776 }
7777
7778 ZEND_VM_HANDLER(122, ZEND_DEFINED, CONST, ANY)
7779 {
7780 USE_OPLINE
7781 zend_constant *c;
7782 int result;
7783
7784 if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))))) {
7785 result = 1;
7786 } else if ((c = zend_quick_get_constant(EX_CONSTANT(opline->op1), 0)) == NULL) {
7787 result = 0;
7788 ZVAL_FALSE(EX_VAR(opline->result.var));
7789 } else {
7790 CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), c);
7791 result = 1;
7792 }
7793 ZEND_VM_SMART_BRANCH(result, 0);
7794 ZVAL_BOOL(EX_VAR(opline->result.var), result);
7795 ZEND_VM_NEXT_OPCODE();
7796 }
7797
7798 ZEND_VM_HANDLER(151, ZEND_ASSERT_CHECK, ANY, ANY)
7799 {
7800 USE_OPLINE
7801
7802 if (EG(assertions) <= 0) {
7803 zend_op *target = OP_JMP_ADDR(opline, opline->op2);
7804 zend_op *result = target - 1;
7805 SKIP_EXT_OPLINE(result);
7806 if (RETURN_VALUE_USED(result)) {
7807 ZVAL_TRUE(EX_VAR(result->result.var));
7808 }
7809 ZEND_VM_JMP(target);
7810 } else {
7811 ZEND_VM_NEXT_OPCODE();
7812 }
7813 }
7814
7815 ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, ANY, ANY)
7816 {
7817 uint32_t fetch_type;
7818 USE_OPLINE
7819
7820 SAVE_OPLINE();
7821 fetch_type = opline->extended_value;
7822
7823 if (UNEXPECTED(EG(scope) == NULL)) {
7824 zend_throw_error(NULL, "Cannot use \"%s\" when no class scope is active",
7825 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
7826 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
7827 HANDLE_EXCEPTION();
7828 }
7829
7830 switch (fetch_type) {
7831 case ZEND_FETCH_CLASS_SELF:
7832 ZVAL_STR_COPY(EX_VAR(opline->result.var), EG(scope)->name);
7833 break;
7834 case ZEND_FETCH_CLASS_PARENT:
7835 if (UNEXPECTED(EG(scope)->parent == NULL)) {
7836 zend_throw_error(NULL,
7837 "Cannot use \"parent\" when current class scope has no parent");
7838 HANDLE_EXCEPTION();
7839 }
7840 ZVAL_STR_COPY(EX_VAR(opline->result.var), EG(scope)->parent->name);
7841 break;
7842 case ZEND_FETCH_CLASS_STATIC:
7843 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(called_scope)->name);
7844 break;
7845 EMPTY_SWITCH_DEFAULT_CASE()
7846 }
7847 ZEND_VM_NEXT_OPCODE();
7848 }
7849
7850 ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY)
7851 {
7852 zend_array *args;
7853 zend_function *fbc = EX(func);
7854 zval *ret = EX(return_value);
7855 uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS);
7856 uint32_t num_args = EX_NUM_ARGS();
7857 zend_execute_data *call;
7858 USE_OPLINE
7859
7860 args = emalloc(sizeof(zend_array));
7861 zend_hash_init(args, num_args, NULL, ZVAL_PTR_DTOR, 0);
7862 if (num_args) {
7863 zval *p = ZEND_CALL_ARG(execute_data, 1);
7864 zval *end = p + num_args;
7865
7866 zend_hash_real_init(args, 1);
7867 ZEND_HASH_FILL_PACKED(args) {
7868 do {
7869 ZEND_HASH_FILL_ADD(p);
7870 p++;
7871 } while (p != end);
7872 } ZEND_HASH_FILL_END();
7873 }
7874
7875 SAVE_OPLINE();
7876 call = execute_data;
7877 execute_data = EG(current_execute_data) = EX(prev_execute_data);
7878
7879 ZEND_ASSERT(zend_vm_calc_used_stack(2, fbc->common.prototype) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
7880
7881 call->func = fbc->common.prototype;
7882 ZEND_CALL_NUM_ARGS(call) = 2;
7883
7884 ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
7885 ZVAL_ARR(ZEND_CALL_ARG(call, 2), args);
7886 zend_free_trampoline(fbc);
7887 fbc = call->func;
7888
7889 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
7890
7891 ZEND_ASSERT(!(fbc->common.fn_flags & ZEND_ACC_GENERATOR));
7892
7893 call->symbol_table = NULL;
7894 i_init_func_execute_data(call, &fbc->op_array,
7895 ret, (fbc->common.fn_flags & ZEND_ACC_STATIC) == 0);
7896
7897 if (EXPECTED(zend_execute_ex == execute_ex)) {
7898 ZEND_VM_ENTER();
7899 } else {
7900 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
7901 zend_execute_ex(call);
7902 }
7903 } else {
7904 zval retval;
7905
7906 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
7907
7908 EG(current_execute_data) = call;
7909
7910 if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
7911 uint32_t i;
7912 uint32_t num_args = ZEND_CALL_NUM_ARGS(call);
7913 zval *p = ZEND_CALL_ARG(call, 1);
7914
7915 EG(current_execute_data) = call;
7916
7917 for (i = 0; i < num_args; ++i) {
7918 if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) {
7919 EG(current_execute_data) = call->prev_execute_data;
7920 zend_vm_stack_free_args(call);
7921 zend_vm_stack_free_call_frame(call);
7922 if (ret) {
7923 ZVAL_UNDEF(ret);
7924 }
7925 ZEND_VM_C_GOTO(call_trampoline_end);
7926 }
7927 p++;
7928 }
7929 }
7930
7931 if (ret == NULL) {
7932 ZVAL_NULL(&retval);
7933 ret = &retval;
7934 }
7935 Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
7936
7937 if (!zend_execute_internal) {
7938
7939 fbc->internal_function.handler(call, ret);
7940 } else {
7941 zend_execute_internal(call, ret);
7942 }
7943
7944 #if ZEND_DEBUG
7945 ZEND_ASSERT(
7946 EG(exception) || !call->func ||
7947 !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
7948 zend_verify_internal_return_type(call->func, EX_VAR(opline->result.var)));
7949 #endif
7950
7951 EG(current_execute_data) = call->prev_execute_data;
7952
7953 zend_vm_stack_free_args(call);
7954
7955 if (ret == &retval) {
7956 zval_ptr_dtor(ret);
7957 }
7958 }
7959
7960 ZEND_VM_C_LABEL(call_trampoline_end):
7961 execute_data = EG(current_execute_data);
7962
7963 if (!EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
7964 ZEND_VM_RETURN();
7965 }
7966
7967 opline = EX(opline);
7968
7969 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
7970 zend_object *object = Z_OBJ(call->This);
7971 OBJ_RELEASE(object);
7972 }
7973 EG(scope) = EX(func)->op_array.scope;
7974 zend_vm_stack_free_call_frame(call);
7975
7976 if (UNEXPECTED(EG(exception) != NULL)) {
7977 zend_throw_exception_internal(NULL);
7978 if (RETURN_VALUE_USED(opline)) {
7979 zval_ptr_dtor(EX_VAR(opline->result.var));
7980 }
7981 HANDLE_EXCEPTION_LEAVE();
7982 }
7983
7984 ZEND_VM_INC_OPCODE();
7985 ZEND_VM_LEAVE();
7986 }
7987
7988 ZEND_VM_DEFINE_OP(137, ZEND_OP_DATA);