1 : /*
2 : +----------------------------------------------------------------------+
3 : | Zend Engine |
4 : +----------------------------------------------------------------------+
5 : | Copyright (c) 1998-2009 Zend Technologies Ltd. (http://www.zend.com) |
6 : +----------------------------------------------------------------------+
7 : | This source file is subject to version 2.00 of the Zend license, |
8 : | that is bundled with this package in the file LICENSE, and is |
9 : | available through the world-wide-web at the following url: |
10 : | http://www.zend.com/license/2_00.txt. |
11 : | If you did not receive a copy of the Zend license and are unable to |
12 : | obtain it through the world-wide-web, please send a note to |
13 : | license@zend.com so we can mail you a copy immediately. |
14 : +----------------------------------------------------------------------+
15 : | Authors: Andi Gutmans <andi@zend.com> |
16 : | Zeev Suraski <zeev@zend.com> |
17 : | Dmitry Stogov <dmitry@zend.com> |
18 : +----------------------------------------------------------------------+
19 : */
20 :
21 : static user_opcode_handler_t zend_user_opcode_handlers[256] = {(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL,(user_opcode_handler_t)NULL};
22 :
23 : static zend_uchar zend_user_opcodes[256] = {0,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,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255};
24 :
25 : static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op);
26 :
27 :
28 : #define ZEND_VM_CONTINUE() return 0
29 : #define ZEND_VM_RETURN() return 1
30 : #define ZEND_VM_ENTER() return 2
31 : #define ZEND_VM_LEAVE() return 3
32 : #define ZEND_VM_DISPATCH(opcode, opline) return zend_vm_get_opcode_handler(opcode, opline)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
33 :
34 : #define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC
35 : #undef EX
36 : #define EX(element) execute_data->element
37 :
38 :
39 : ZEND_API void execute(zend_op_array *op_array TSRMLS_DC)
40 359111 : {
41 : zend_execute_data *execute_data;
42 359111 : zend_bool nested = 0;
43 359111 : zend_bool original_in_execution = EG(in_execution);
44 :
45 :
46 359111 : if (EG(exception)) {
47 1 : return;
48 : }
49 :
50 359110 : EG(in_execution) = 1;
51 :
52 1232868 : zend_vm_enter:
53 : /* Initialize execute_data */
54 1232868 : execute_data = (zend_execute_data *)zend_vm_stack_alloc(
55 : ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data)) +
56 : ZEND_MM_ALIGNED_SIZE(sizeof(zval**) * op_array->last_var * (EG(active_symbol_table) ? 1 : 2)) +
57 : ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T TSRMLS_CC);
58 :
59 1232868 : EX(CVs) = (zval***)((char*)execute_data + ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data)));
60 1232868 : memset(EX(CVs), 0, sizeof(zval**) * op_array->last_var);
61 1232868 : EX(Ts) = (temp_variable *)(((char*)EX(CVs)) + ZEND_MM_ALIGNED_SIZE(sizeof(zval**) * op_array->last_var * (EG(active_symbol_table) ? 1 : 2)));
62 1232868 : EX(fbc) = NULL;
63 1232868 : EX(called_scope) = NULL;
64 1232868 : EX(object) = NULL;
65 1232868 : EX(old_error_reporting) = NULL;
66 1232868 : EX(op_array) = op_array;
67 1232868 : EX(symbol_table) = EG(active_symbol_table);
68 1232868 : EX(prev_execute_data) = EG(current_execute_data);
69 1232868 : EG(current_execute_data) = execute_data;
70 1232868 : EX(nested) = nested;
71 1232868 : nested = 1;
72 :
73 1232868 : if (op_array->start_op) {
74 0 : ZEND_VM_SET_OPCODE(op_array->start_op);
75 : } else {
76 1232868 : ZEND_VM_SET_OPCODE(op_array->opcodes);
77 : }
78 :
79 1232868 : if (op_array->this_var != -1 && EG(This)) {
80 446 : Z_ADDREF_P(EG(This)); /* For $this pointer */
81 446 : if (!EG(active_symbol_table)) {
82 446 : EX(CVs)[op_array->this_var] = (zval**)EX(CVs) + (op_array->last_var + op_array->this_var);
83 446 : *EX(CVs)[op_array->this_var] = EG(This);
84 : } else {
85 0 : if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), (void**)&EX(CVs)[op_array->this_var])==FAILURE) {
86 0 : Z_DELREF_P(EG(This));
87 : }
88 : }
89 : }
90 :
91 1232868 : EG(opline_ptr) = &EX(opline);
92 :
93 1232868 : EX(function_state).function = (zend_function *) op_array;
94 1232868 : EX(function_state).arguments = NULL;
95 :
96 : while (1) {
97 : int ret;
98 : #ifdef ZEND_WIN32
99 : if (EG(timed_out)) {
100 : zend_timeout(0);
101 : }
102 : #endif
103 :
104 144543797 : if ((ret = EX(opline)->handler(execute_data TSRMLS_CC)) > 0) {
105 2105388 : switch (ret) {
106 : case 1:
107 357992 : EG(in_execution) = original_in_execution;
108 357992 : return;
109 : case 2:
110 873758 : op_array = EG(active_op_array);
111 873758 : goto zend_vm_enter;
112 : case 3:
113 873638 : execute_data = EG(current_execute_data);
114 : default:
115 : break;
116 : }
117 : }
118 :
119 143310929 : }
120 : zend_error_noreturn(E_ERROR, "Arrived at end of main loop which shouldn't happen");
121 : }
122 :
123 : static int ZEND_FASTCALL ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
124 13906496 : {
125 : #if DEBUG_ZEND>=2
126 : printf("Jumping to %d\n", EX(opline)->op1.u.opline_num);
127 : #endif
128 13906496 : ZEND_VM_SET_OPCODE(EX(opline)->op1.u.jmp_addr);
129 13906496 : ZEND_VM_CONTINUE(); /* CHECK_ME */
130 : }
131 :
132 : static int ZEND_FASTCALL ZEND_INIT_STRING_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
133 0 : {
134 0 : zval *tmp = &EX_T(EX(opline)->result.u.var).tmp_var;
135 :
136 0 : tmp->value.str.val = emalloc(1);
137 0 : tmp->value.str.val[0] = 0;
138 0 : tmp->value.str.len = 0;
139 0 : Z_SET_REFCOUNT_P(tmp, 1);
140 0 : tmp->type = IS_STRING;
141 0 : Z_UNSET_ISREF_P(tmp);
142 0 : ZEND_VM_NEXT_OPCODE();
143 : }
144 :
145 : static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
146 1231630 : {
147 : zend_bool nested;
148 1231630 : zend_op_array *op_array = EX(op_array);
149 :
150 1231630 : EG(current_execute_data) = EX(prev_execute_data);
151 1231630 : EG(opline_ptr) = NULL;
152 1231630 : if (!EG(active_symbol_table)) {
153 1176481 : zval ***cv = EX(CVs);
154 1176481 : zval ***end = cv + EX(op_array)->last_var;
155 7174545 : while (cv != end) {
156 4821583 : if (*cv) {
157 4152143 : zval_ptr_dtor(*cv);
158 : }
159 4821583 : cv++;
160 : }
161 : }
162 :
163 1231630 : nested = EX(nested);
164 :
165 1231630 : zend_vm_stack_free(execute_data TSRMLS_CC);
166 :
167 1231630 : if (nested) {
168 873638 : execute_data = EG(current_execute_data);
169 :
170 873638 : if (EX(call_opline)->opcode == ZEND_INCLUDE_OR_EVAL) {
171 :
172 8525 : EX(function_state).function = (zend_function *) EX(op_array);
173 8525 : EX(function_state).arguments = NULL;
174 8525 : EX(object) = EX(current_object);
175 :
176 8525 : if (RETURN_VALUE_USED(EX(call_opline))) {
177 480 : if (!EX_T(EX(call_opline)->result.u.var).var.ptr) { /* there was no return statement */
178 0 : ALLOC_ZVAL(EX_T(EX(call_opline)->result.u.var).var.ptr);
179 0 : INIT_PZVAL(EX_T(EX(call_opline)->result.u.var).var.ptr);
180 0 : Z_LVAL_P(EX_T(EX(call_opline)->result.u.var).var.ptr) = 1;
181 0 : Z_TYPE_P(EX_T(EX(call_opline)->result.u.var).var.ptr) = IS_BOOL;
182 : }
183 : }
184 :
185 8525 : EG(opline_ptr) = &EX(opline);
186 8525 : EG(active_op_array) = EX(op_array);
187 8525 : EG(return_value_ptr_ptr) = EX(original_return_value);
188 8525 : destroy_op_array(op_array TSRMLS_CC);
189 8525 : efree(op_array);
190 8525 : if (EG(exception)) {
191 18 : zend_throw_exception_internal(NULL TSRMLS_CC);
192 : }
193 :
194 8525 : EX(opline)++;
195 8525 : ZEND_VM_LEAVE();
196 : } else {
197 :
198 865113 : EG(opline_ptr) = &EX(opline);
199 865113 : EG(active_op_array) = EX(op_array);
200 865113 : EG(return_value_ptr_ptr) = EX(original_return_value);
201 865113 : if (EG(active_symbol_table)) {
202 30026 : if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) {
203 0 : zend_hash_destroy(EG(active_symbol_table));
204 0 : FREE_HASHTABLE(EG(active_symbol_table));
205 : } else {
206 : /* clean before putting into the cache, since clean
207 : could call dtors, which could use cached hash */
208 30026 : zend_hash_clean(EG(active_symbol_table));
209 30026 : *(++EG(symtable_cache_ptr)) = EG(active_symbol_table);
210 : }
211 : }
212 865113 : EG(active_symbol_table) = EX(symbol_table);
213 :
214 865113 : EX(function_state).function = (zend_function *) EX(op_array);
215 865113 : EX(function_state).arguments = NULL;
216 :
217 865113 : if (EG(This)) {
218 2701 : if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
219 20 : if (IS_CTOR_USED(EX(called_scope))) {
220 17 : Z_DELREF_P(EG(This));
221 : }
222 20 : if (Z_REFCOUNT_P(EG(This)) == 1) {
223 19 : zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
224 : }
225 : }
226 2701 : zval_ptr_dtor(&EG(This));
227 : }
228 865113 : EG(This) = EX(current_this);
229 865113 : EG(scope) = EX(current_scope);
230 865113 : EG(called_scope) = EX(current_called_scope);
231 :
232 865113 : EX(object) = EX(current_object);
233 865113 : EX(called_scope) = DECODE_CTOR(EX(called_scope));
234 :
235 865113 : zend_vm_stack_clear_multiple(TSRMLS_C);
236 :
237 865113 : if (EG(exception)) {
238 119 : zend_throw_exception_internal(NULL TSRMLS_CC);
239 119 : if (RETURN_VALUE_USED(EX(call_opline)) && EX_T(EX(call_opline)->result.u.var).var.ptr) {
240 0 : zval_ptr_dtor(&EX_T(EX(call_opline)->result.u.var).var.ptr);
241 : }
242 : }
243 :
244 865113 : EX(opline)++;
245 865113 : ZEND_VM_LEAVE();
246 : }
247 : }
248 357992 : ZEND_VM_RETURN();
249 : }
250 :
251 : static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
252 16451862 : {
253 16451862 : zend_op *opline = EX(opline);
254 16451862 : zend_bool should_change_scope = 0;
255 :
256 16451862 : if (EX(function_state).function->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) {
257 937 : if (EX(function_state).function->common.fn_flags & ZEND_ACC_ABSTRACT) {
258 1 : zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
259 : ZEND_VM_NEXT_OPCODE(); /* Never reached */
260 : }
261 936 : if (EX(function_state).function->common.fn_flags & ZEND_ACC_DEPRECATED) {
262 936 : zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
263 : EX(function_state).function->common.scope ? EX(function_state).function->common.scope->name : "",
264 : EX(function_state).function->common.scope ? "::" : "",
265 : EX(function_state).function->common.function_name);
266 : }
267 : }
268 16451861 : if (EX(function_state).function->common.scope &&
269 : !(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC) &&
270 : !EX(object)) {
271 :
272 31 : if (EX(function_state).function->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
273 : /* FIXME: output identifiers properly */
274 22 : zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
275 : } else {
276 : /* FIXME: output identifiers properly */
277 : /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
278 9 : zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
279 : }
280 : }
281 :
282 16451852 : if (EX(function_state).function->type == ZEND_USER_FUNCTION ||
283 : EX(function_state).function->common.scope) {
284 1100099 : should_change_scope = 1;
285 1100099 : EX(current_this) = EG(This);
286 1100099 : EX(current_scope) = EG(scope);
287 1100099 : EX(current_called_scope) = EG(called_scope);
288 1100099 : EG(This) = EX(object);
289 1100099 : EG(scope) = (EX(function_state).function->type == ZEND_USER_FUNCTION || !EX(object)) ? EX(function_state).function->common.scope : NULL;
290 1100099 : EG(called_scope) = EX(called_scope);
291 : }
292 :
293 16451852 : zend_arg_types_stack_3_pop(&EG(arg_types_stack), &EX(called_scope), &EX(current_object), &EX(fbc));
294 16451852 : EX(function_state).arguments = zend_vm_stack_push_args(opline->extended_value TSRMLS_CC);
295 :
296 16451852 : if (EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
297 15586655 : ALLOC_INIT_ZVAL(EX_T(opline->result.u.var).var.ptr);
298 15586655 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
299 15586655 : EX_T(opline->result.u.var).var.fcall_returned_reference = EX(function_state).function->common.return_reference;
300 :
301 15586655 : if (EX(function_state).function->common.arg_info) {
302 15492718 : zend_uint i=0;
303 15492718 : zval **p = (zval**)EX(function_state).arguments;
304 15492718 : ulong arg_count = opline->extended_value;
305 :
306 57061902 : while (arg_count>0) {
307 26076470 : zend_verify_arg_type(EX(function_state).function, ++i, *(p-arg_count), 0 TSRMLS_CC);
308 26076466 : arg_count--;
309 : }
310 : }
311 15586651 : if (!zend_execute_internal) {
312 : /* saves one function call if zend_execute_internal is not used */
313 15586651 : ((zend_internal_function *) EX(function_state).function)->handler(opline->extended_value, EX_T(opline->result.u.var).var.ptr, EX(function_state).function->common.return_reference?&EX_T(opline->result.u.var).var.ptr:NULL, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
314 : } else {
315 0 : zend_execute_internal(execute_data, RETURN_VALUE_USED(opline) TSRMLS_CC);
316 : }
317 :
318 15586517 : if (!RETURN_VALUE_USED(opline)) {
319 1150770 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
320 : }
321 865197 : } else if (EX(function_state).function->type == ZEND_USER_FUNCTION) {
322 865197 : EX(original_return_value) = EG(return_value_ptr_ptr);
323 865197 : EG(active_symbol_table) = NULL;
324 865197 : EG(active_op_array) = &EX(function_state).function->op_array;
325 865197 : EG(return_value_ptr_ptr) = NULL;
326 865197 : if (RETURN_VALUE_USED(opline)) {
327 741950 : EG(return_value_ptr_ptr) = &EX_T(opline->result.u.var).var.ptr;
328 741950 : EX_T(opline->result.u.var).var.ptr = NULL;
329 741950 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
330 741950 : EX_T(opline->result.u.var).var.fcall_returned_reference = EX(function_state).function->common.return_reference;
331 : }
332 :
333 865197 : if (zend_execute == execute && !EG(exception)) {
334 865196 : EX(call_opline) = opline;
335 865196 : ZEND_VM_ENTER();
336 : } else {
337 1 : zend_execute(EG(active_op_array) TSRMLS_CC);
338 : }
339 :
340 1 : EG(opline_ptr) = &EX(opline);
341 1 : EG(active_op_array) = EX(op_array);
342 1 : EG(return_value_ptr_ptr) = EX(original_return_value);
343 1 : if (EG(active_symbol_table)) {
344 0 : if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) {
345 0 : zend_hash_destroy(EG(active_symbol_table));
346 0 : FREE_HASHTABLE(EG(active_symbol_table));
347 : } else {
348 : /* clean before putting into the cache, since clean
349 : could call dtors, which could use cached hash */
350 0 : zend_hash_clean(EG(active_symbol_table));
351 0 : *(++EG(symtable_cache_ptr)) = EG(active_symbol_table);
352 : }
353 : }
354 1 : EG(active_symbol_table) = EX(symbol_table);
355 : } else { /* ZEND_OVERLOADED_FUNCTION */
356 0 : ALLOC_INIT_ZVAL(EX_T(opline->result.u.var).var.ptr);
357 :
358 : /* Not sure what should be done here if it's a static method */
359 0 : if (EX(object)) {
360 0 : Z_OBJ_HT_P(EX(object))->call_method(EX(function_state).function->common.function_name, opline->extended_value, EX_T(opline->result.u.var).var.ptr, &EX_T(opline->result.u.var).var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
361 : } else {
362 0 : zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
363 : }
364 :
365 0 : if (EX(function_state).function->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
366 0 : efree(EX(function_state).function->common.function_name);
367 : }
368 0 : efree(EX(function_state).function);
369 :
370 0 : if (!RETURN_VALUE_USED(opline)) {
371 0 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
372 : } else {
373 0 : Z_UNSET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
374 0 : Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
375 0 : EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
376 0 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
377 : }
378 : }
379 :
380 15586518 : EX(function_state).function = (zend_function *) EX(op_array);
381 15586518 : EX(function_state).arguments = NULL;
382 :
383 15586518 : if (should_change_scope) {
384 234761 : if (EG(This)) {
385 232912 : if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
386 270 : if (IS_CTOR_USED(EX(called_scope))) {
387 212 : Z_DELREF_P(EG(This));
388 : }
389 270 : if (Z_REFCOUNT_P(EG(This)) == 1) {
390 270 : zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
391 : }
392 : }
393 232912 : zval_ptr_dtor(&EG(This));
394 : }
395 234761 : EG(This) = EX(current_this);
396 234761 : EG(scope) = EX(current_scope);
397 234761 : EG(called_scope) = EX(current_called_scope);
398 : }
399 :
400 15586518 : EX(object) = EX(current_object);
401 15586518 : EX(called_scope) = DECODE_CTOR(EX(called_scope));
402 :
403 15586518 : zend_vm_stack_clear_multiple(TSRMLS_C);
404 :
405 15586518 : if (EG(exception)) {
406 878 : zend_throw_exception_internal(NULL TSRMLS_CC);
407 878 : if (RETURN_VALUE_USED(opline) && EX_T(opline->result.u.var).var.ptr) {
408 252 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
409 : }
410 : }
411 :
412 15586518 : ZEND_VM_NEXT_OPCODE();
413 : }
414 :
415 : static int ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
416 466313 : {
417 466313 : EX(function_state).function = EX(fbc);
418 466313 : return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
419 : }
420 :
421 : static int ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
422 2995416 : {
423 2995416 : zend_op *opline = EX(opline);
424 2995416 : zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
425 2995416 : zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
426 :
427 2995416 : if (param == NULL) {
428 : char *space;
429 71 : char *class_name = get_active_class_name(&space TSRMLS_CC);
430 71 : zend_execute_data *ptr = EX(prev_execute_data);
431 :
432 71 : if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value TSRMLS_CC)) {
433 79 : if(ptr && ptr->op_array) {
434 12 : zend_error(E_WARNING, "Missing argument %ld for %s%s%s(), called in %s on line %d and defined", opline->op1.u.constant.value.lval, class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno);
435 : } else {
436 55 : zend_error(E_WARNING, "Missing argument %ld for %s%s%s()", opline->op1.u.constant.value.lval, class_name, space, get_active_function_name(TSRMLS_C));
437 : }
438 : }
439 68 : if (opline->result.op_type == IS_VAR) {
440 0 : PZVAL_UNLOCK_FREE(*EX_T(opline->result.u.var).var.ptr_ptr);
441 : }
442 : } else {
443 : zend_free_op free_res;
444 : zval **var_ptr;
445 :
446 2995345 : zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC);
447 2995332 : var_ptr = get_zval_ptr_ptr(&opline->result, EX(Ts), &free_res, BP_VAR_W);
448 2995332 : Z_DELREF_PP(var_ptr);
449 2995332 : *var_ptr = *param;
450 2995332 : Z_ADDREF_PP(var_ptr);
451 : }
452 :
453 2995400 : ZEND_VM_NEXT_OPCODE();
454 : }
455 :
456 : static int ZEND_FASTCALL ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
457 115136 : {
458 115136 : zend_op *opline = EX(opline);
459 : zval *object_zval;
460 : zend_function *constructor;
461 :
462 115136 : if (EX_T(opline->op1.u.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
463 : char *class_type;
464 :
465 6 : if (EX_T(opline->op1.u.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
466 2 : class_type = "interface";
467 : } else {
468 4 : class_type = "abstract class";
469 : }
470 6 : zend_error_noreturn(E_ERROR, "Cannot instantiate %s %s", class_type, EX_T(opline->op1.u.var).class_entry->name);
471 : }
472 115130 : ALLOC_ZVAL(object_zval);
473 115130 : object_init_ex(object_zval, EX_T(opline->op1.u.var).class_entry);
474 115129 : INIT_PZVAL(object_zval);
475 :
476 115129 : constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
477 :
478 115124 : if (constructor == NULL) {
479 106803 : if (RETURN_VALUE_USED(opline)) {
480 106792 : AI_SET_PTR(EX_T(opline->result.u.var).var, object_zval);
481 : } else {
482 11 : zval_ptr_dtor(&object_zval);
483 : }
484 106803 : ZEND_VM_JMP(EX(op_array)->opcodes + opline->op2.u.opline_num);
485 : } else {
486 8321 : if (RETURN_VALUE_USED(opline)) {
487 8187 : AI_SET_PTR(EX_T(opline->result.u.var).var, object_zval);
488 8187 : PZVAL_LOCK(object_zval);
489 : }
490 :
491 8321 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), ENCODE_CTOR(EX(called_scope), RETURN_VALUE_USED(opline)));
492 :
493 : /* We are not handling overloaded classes right now */
494 8321 : EX(object) = object_zval;
495 8321 : EX(fbc) = constructor;
496 8321 : EX(called_scope) = EX_T(opline->op1.u.var).class_entry;
497 :
498 8321 : ZEND_VM_NEXT_OPCODE();
499 : }
500 : }
501 :
502 : static int ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
503 1139855 : {
504 1139855 : zend_op *opline = EX(opline);
505 :
506 1139855 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = EG(error_reporting);
507 1139855 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG; /* shouldn't be necessary */
508 1139855 : if (EX(old_error_reporting) == NULL) {
509 1139842 : EX(old_error_reporting) = &EX_T(opline->result.u.var).tmp_var;
510 : }
511 :
512 1139855 : if (EG(error_reporting)) {
513 1003400 : zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), "0", 1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
514 : }
515 1139855 : ZEND_VM_NEXT_OPCODE();
516 : }
517 :
518 : static int ZEND_FASTCALL ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
519 0 : {
520 0 : zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name);
521 : ZEND_VM_NEXT_OPCODE(); /* Never reached */
522 : }
523 :
524 : static int ZEND_FASTCALL ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
525 0 : {
526 0 : if (!EG(no_extensions)) {
527 0 : zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, EX(op_array) TSRMLS_CC);
528 : }
529 0 : ZEND_VM_NEXT_OPCODE();
530 : }
531 :
532 : static int ZEND_FASTCALL ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
533 0 : {
534 0 : if (!EG(no_extensions)) {
535 0 : zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, EX(op_array) TSRMLS_CC);
536 : }
537 0 : ZEND_VM_NEXT_OPCODE();
538 : }
539 :
540 : static int ZEND_FASTCALL ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
541 0 : {
542 0 : if (!EG(no_extensions)) {
543 0 : zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, EX(op_array) TSRMLS_CC);
544 : }
545 0 : ZEND_VM_NEXT_OPCODE();
546 : }
547 :
548 : static int ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
549 239 : {
550 239 : zend_op *opline = EX(opline);
551 :
552 239 : EX_T(opline->result.u.var).class_entry = do_bind_class(opline, EG(class_table), 0 TSRMLS_CC);
553 237 : ZEND_VM_NEXT_OPCODE();
554 : }
555 :
556 : static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
557 1120 : {
558 1120 : zend_op *opline = EX(opline);
559 :
560 1120 : EX_T(opline->result.u.var).class_entry = do_bind_inherited_class(opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
561 1118 : ZEND_VM_NEXT_OPCODE();
562 : }
563 :
564 : static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
565 0 : {
566 0 : zend_op *opline = EX(opline);
567 : zend_class_entry **pce, **pce_orig;
568 :
569 0 : if (zend_hash_find(EG(class_table), Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void**)&pce) == FAILURE ||
570 : (zend_hash_find(EG(class_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), (void**)&pce_orig) == SUCCESS &&
571 : *pce != *pce_orig)) {
572 0 : do_bind_inherited_class(opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
573 : }
574 0 : ZEND_VM_NEXT_OPCODE();
575 : }
576 :
577 : static int ZEND_FASTCALL ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
578 1962 : {
579 1962 : do_bind_function(EX(opline), EG(function_table), 0);
580 1962 : ZEND_VM_NEXT_OPCODE();
581 : }
582 :
583 : static int ZEND_FASTCALL ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
584 0 : {
585 0 : ZEND_VM_NEXT_OPCODE();
586 : }
587 :
588 : static int ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
589 16112 : {
590 16112 : ZEND_VM_NEXT_OPCODE();
591 : }
592 :
593 : static int ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
594 1315 : {
595 1315 : zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes;
596 : int i;
597 : zend_uint catch_op_num;
598 1315 : int catched = 0;
599 : zval restored_error_reporting;
600 :
601 : void **stack_frame = (void**)(((char*)EX(Ts)) +
602 1315 : (ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * EX(op_array)->T));
603 :
604 2692 : while (zend_vm_stack_top(TSRMLS_C) != stack_frame) {
605 62 : zval *stack_zval_p = zend_vm_stack_pop(TSRMLS_C);
606 62 : zval_ptr_dtor(&stack_zval_p);
607 : }
608 :
609 3704 : for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
610 2766 : if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
611 : /* further blocks will not be relevant... */
612 377 : break;
613 : }
614 2389 : if (op_num >= EG(active_op_array)->try_catch_array[i].try_op
615 : && op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
616 979 : catch_op_num = EX(op_array)->try_catch_array[i].catch_op;
617 979 : catched = 1;
618 : }
619 : }
620 :
621 2649 : while (EX(fbc)) {
622 19 : EX(called_scope) = (zend_class_entry*)zend_ptr_stack_pop(&EG(arg_types_stack));
623 19 : if (EX(object)) {
624 10 : if (IS_CTOR_CALL(EX(called_scope))) {
625 3 : if (IS_CTOR_USED(EX(called_scope))) {
626 2 : Z_DELREF_P(EX(object));
627 : }
628 3 : if (Z_REFCOUNT_P(EX(object)) == 1) {
629 3 : zend_object_store_ctor_failed(EX(object) TSRMLS_CC);
630 : }
631 : }
632 10 : zval_ptr_dtor(&EX(object));
633 : }
634 19 : EX(called_scope) = DECODE_CTOR(EX(called_scope));
635 19 : zend_arg_types_stack_2_pop(&EG(arg_types_stack), &EX(object), &EX(fbc));
636 : }
637 :
638 1750 : for (i=0; i<EX(op_array)->last_brk_cont; i++) {
639 514 : if (EX(op_array)->brk_cont_array[i].start < 0) {
640 81 : continue;
641 433 : } else if (EX(op_array)->brk_cont_array[i].start > op_num) {
642 : /* further blocks will not be relevant... */
643 79 : break;
644 354 : } else if (op_num < EX(op_array)->brk_cont_array[i].brk) {
645 225 : if (!catched ||
646 : catch_op_num >= EX(op_array)->brk_cont_array[i].brk) {
647 8 : zend_op *brk_opline = &EX(op_array)->opcodes[EX(op_array)->brk_cont_array[i].brk];
648 :
649 8 : switch (brk_opline->opcode) {
650 : case ZEND_SWITCH_FREE:
651 7 : if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
652 7 : zend_switch_free(&EX_T(brk_opline->op1.u.var), brk_opline->extended_value TSRMLS_CC);
653 : }
654 7 : break;
655 : case ZEND_FREE:
656 0 : if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
657 0 : zendi_zval_dtor(EX_T(brk_opline->op1.u.var).tmp_var);
658 : }
659 : break;
660 : }
661 : }
662 : }
663 : }
664 :
665 : /* restore previous error_reporting value */
666 1315 : if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) {
667 13 : Z_TYPE(restored_error_reporting) = IS_LONG;
668 13 : Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting));
669 13 : convert_to_string(&restored_error_reporting);
670 13 : zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
671 13 : zendi_zval_dtor(restored_error_reporting);
672 : }
673 1315 : EX(old_error_reporting) = NULL;
674 :
675 1315 : if (!catched) {
676 353 : return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
677 : } else {
678 962 : ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
679 962 : ZEND_VM_CONTINUE();
680 : }
681 : }
682 :
683 : static int ZEND_FASTCALL ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
684 222 : {
685 222 : zend_verify_abstract_class(EX_T(EX(opline)->op1.u.var).class_entry TSRMLS_CC);
686 217 : ZEND_VM_NEXT_OPCODE();
687 : }
688 :
689 : static int ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
690 0 : {
691 0 : int ret = zend_user_opcode_handlers[EX(opline)->opcode](ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL);
692 :
693 0 : switch (ret) {
694 : case ZEND_USER_OPCODE_CONTINUE:
695 0 : ZEND_VM_CONTINUE();
696 : case ZEND_USER_OPCODE_RETURN:
697 0 : return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
698 : case ZEND_USER_OPCODE_ENTER:
699 0 : ZEND_VM_ENTER();
700 : case ZEND_USER_OPCODE_LEAVE:
701 0 : ZEND_VM_LEAVE();
702 : case ZEND_USER_OPCODE_DISPATCH:
703 0 : ZEND_VM_DISPATCH(EX(opline)->opcode, EX(opline));
704 : default:
705 0 : ZEND_VM_DISPATCH((zend_uchar)(ret & 0xff), EX(opline));
706 : }
707 : }
708 :
709 : static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
710 116478 : {
711 116478 : zend_op *opline = EX(opline);
712 :
713 :
714 : if (IS_CONST == IS_UNUSED) {
715 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
716 : ZEND_VM_NEXT_OPCODE();
717 : } else {
718 :
719 116478 : zval *class_name = &opline->op2.u.constant;
720 :
721 : if (IS_CONST != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
722 : EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
723 116478 : } else if (Z_TYPE_P(class_name) == IS_STRING) {
724 116478 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
725 : } else {
726 0 : zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
727 : }
728 :
729 116467 : ZEND_VM_NEXT_OPCODE();
730 : }
731 : }
732 :
733 : static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
734 212682 : {
735 212682 : zend_op *opline = EX(opline);
736 : zval *function_name;
737 : char *function_name_strval, *lcname;
738 : int function_name_strlen;
739 :
740 :
741 212682 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
742 :
743 : if (IS_CONST == IS_CONST) {
744 212682 : if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc)) == FAILURE) {
745 12 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
746 : }
747 : } else {
748 : function_name = &opline->op2.u.constant;
749 :
750 : if (IS_CONST != IS_CONST &&
751 : Z_TYPE_P(function_name) == IS_OBJECT &&
752 : Z_OBJ_HANDLER_P(function_name, get_closure) &&
753 : Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) {
754 : if (EX(object)) {
755 : Z_ADDREF_P(EX(object));
756 : }
757 :
758 : ZEND_VM_NEXT_OPCODE();
759 : }
760 :
761 : if (Z_TYPE_P(function_name) != IS_STRING) {
762 : zend_error_noreturn(E_ERROR, "Function name must be a string");
763 : }
764 : function_name_strval = Z_STRVAL_P(function_name);
765 : function_name_strlen = Z_STRLEN_P(function_name);
766 : if (function_name_strval[0] == '\\') {
767 :
768 : function_name_strlen -= 1;
769 : lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
770 : } else {
771 : lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
772 : }
773 : if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE) {
774 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
775 : }
776 : efree(lcname);
777 :
778 : }
779 :
780 212670 : EX(object) = NULL;
781 212670 : ZEND_VM_NEXT_OPCODE();
782 : }
783 :
784 :
785 : static int ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
786 271 : {
787 271 : zend_op *opline = EX(opline);
788 271 : zend_op *op_data = opline + 1;
789 :
790 271 : ZEND_VM_INC_OPCODE();
791 271 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
792 :
793 271 : if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc))==FAILURE) {
794 222 : char *short_name = Z_STRVAL(opline->op1.u.constant)+Z_LVAL(op_data->op1.u.constant);
795 222 : if (zend_hash_quick_find(EG(function_table), short_name, Z_STRLEN(opline->op1.u.constant)-Z_LVAL(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==FAILURE) {
796 0 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
797 : }
798 : }
799 :
800 271 : EX(object) = NULL;
801 271 : ZEND_VM_NEXT_OPCODE();
802 : }
803 :
804 : static int ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
805 138831 : {
806 138831 : zend_op *opline = EX(opline);
807 : zval *assignment_value;
808 138831 : zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
809 : zend_free_op free_res;
810 138831 : zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
811 : zval **var_ptr;
812 :
813 138831 : if (param == NULL) {
814 43467 : ALLOC_ZVAL(assignment_value);
815 43467 : *assignment_value = opline->op2.u.constant;
816 43650 : if ((Z_TYPE(opline->op2.u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT || Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) {
817 203 : Z_SET_REFCOUNT_P(assignment_value, 1);
818 203 : zval_update_constant(&assignment_value, 0 TSRMLS_CC);
819 : } else {
820 43264 : zval_copy_ctor(assignment_value);
821 : }
822 43447 : INIT_PZVAL(assignment_value);
823 : } else {
824 95364 : assignment_value = *param;
825 95364 : Z_ADDREF_P(assignment_value);
826 : }
827 :
828 138811 : zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value, opline->extended_value TSRMLS_CC);
829 138809 : var_ptr = get_zval_ptr_ptr(&opline->result, EX(Ts), &free_res, BP_VAR_W);
830 138809 : Z_DELREF_PP(var_ptr);
831 138809 : *var_ptr = assignment_value;
832 :
833 138809 : ZEND_VM_NEXT_OPCODE();
834 : }
835 :
836 : static int ZEND_FASTCALL ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
837 19316 : {
838 19316 : zend_op *opline = EX(opline);
839 :
840 : zend_brk_cont_element *el;
841 :
842 19316 : el = zend_brk_cont(&opline->op2.u.constant, opline->op1.u.opline_num,
843 : EX(op_array), EX(Ts) TSRMLS_CC);
844 :
845 19316 : ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
846 : }
847 :
848 : static int ZEND_FASTCALL ZEND_CONT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
849 36036 : {
850 36036 : zend_op *opline = EX(opline);
851 :
852 : zend_brk_cont_element *el;
853 :
854 36036 : el = zend_brk_cont(&opline->op2.u.constant, opline->op1.u.opline_num,
855 : EX(op_array), EX(Ts) TSRMLS_CC);
856 :
857 36036 : ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
858 : }
859 :
860 : static int ZEND_FASTCALL ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
861 2 : {
862 : zend_op *brk_opline;
863 2 : zend_op *opline = EX(opline);
864 : zend_brk_cont_element *el;
865 :
866 2 : el = zend_brk_cont(&opline->op2.u.constant, opline->extended_value,
867 : EX(op_array), EX(Ts) TSRMLS_CC);
868 :
869 2 : brk_opline = EX(op_array)->opcodes + el->brk;
870 :
871 2 : switch (brk_opline->opcode) {
872 : case ZEND_SWITCH_FREE:
873 1 : if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
874 1 : zend_switch_free(&EX_T(brk_opline->op1.u.var), brk_opline->extended_value TSRMLS_CC);
875 : }
876 1 : break;
877 : case ZEND_FREE:
878 0 : if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
879 0 : zendi_zval_dtor(EX_T(brk_opline->op1.u.var).tmp_var);
880 : }
881 : break;
882 : }
883 2 : ZEND_VM_JMP(opline->op1.u.jmp_addr);
884 : }
885 :
886 : static int ZEND_FASTCALL ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
887 308 : {
888 308 : zend_op *opline = EX(opline);
889 308 : zend_class_entry *ce = EX_T(opline->op1.u.var).class_entry;
890 308 : zend_class_entry *iface = zend_fetch_class(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), opline->extended_value TSRMLS_CC);
891 :
892 306 : if (iface) {
893 305 : if (!(iface->ce_flags & ZEND_ACC_INTERFACE)) {
894 3 : zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
895 : }
896 302 : zend_do_implement_interface(ce, iface TSRMLS_CC);
897 : }
898 :
899 288 : ZEND_VM_NEXT_OPCODE();
900 : }
901 :
902 : static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
903 0 : {
904 0 : zend_op *opline = EX(opline);
905 :
906 :
907 : if (IS_TMP_VAR == IS_UNUSED) {
908 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
909 : ZEND_VM_NEXT_OPCODE();
910 : } else {
911 : zend_free_op free_op2;
912 0 : zval *class_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
913 :
914 0 : if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
915 0 : EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
916 0 : } else if (Z_TYPE_P(class_name) == IS_STRING) {
917 0 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
918 : } else {
919 0 : zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
920 : }
921 :
922 0 : zval_dtor(free_op2.var);
923 0 : ZEND_VM_NEXT_OPCODE();
924 : }
925 : }
926 :
927 : static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
928 0 : {
929 0 : zend_op *opline = EX(opline);
930 : zval *function_name;
931 : char *function_name_strval, *lcname;
932 : int function_name_strlen;
933 : zend_free_op free_op2;
934 :
935 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
936 :
937 : if (IS_TMP_VAR == IS_CONST) {
938 : if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc)) == FAILURE) {
939 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
940 : }
941 : } else {
942 0 : function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
943 :
944 0 : if (IS_TMP_VAR != IS_CONST &&
945 : Z_TYPE_P(function_name) == IS_OBJECT &&
946 : Z_OBJ_HANDLER_P(function_name, get_closure) &&
947 : Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) {
948 0 : if (EX(object)) {
949 0 : Z_ADDREF_P(EX(object));
950 : }
951 0 : zval_dtor(free_op2.var);
952 0 : ZEND_VM_NEXT_OPCODE();
953 : }
954 :
955 0 : if (Z_TYPE_P(function_name) != IS_STRING) {
956 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
957 : }
958 0 : function_name_strval = Z_STRVAL_P(function_name);
959 0 : function_name_strlen = Z_STRLEN_P(function_name);
960 0 : if (function_name_strval[0] == '\\') {
961 :
962 0 : function_name_strlen -= 1;
963 0 : lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
964 : } else {
965 0 : lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
966 : }
967 0 : if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE) {
968 0 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
969 : }
970 0 : efree(lcname);
971 0 : zval_dtor(free_op2.var);
972 : }
973 :
974 0 : EX(object) = NULL;
975 0 : ZEND_VM_NEXT_OPCODE();
976 : }
977 :
978 :
979 : static int ZEND_FASTCALL ZEND_BRK_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
980 0 : {
981 0 : zend_op *opline = EX(opline);
982 : zend_free_op free_op2;
983 : zend_brk_cont_element *el;
984 :
985 0 : el = zend_brk_cont(_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
986 : EX(op_array), EX(Ts) TSRMLS_CC);
987 0 : zval_dtor(free_op2.var);
988 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
989 : }
990 :
991 : static int ZEND_FASTCALL ZEND_CONT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
992 0 : {
993 0 : zend_op *opline = EX(opline);
994 : zend_free_op free_op2;
995 : zend_brk_cont_element *el;
996 :
997 0 : el = zend_brk_cont(_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
998 : EX(op_array), EX(Ts) TSRMLS_CC);
999 0 : zval_dtor(free_op2.var);
1000 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
1001 : }
1002 :
1003 : static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1004 7 : {
1005 7 : zend_op *opline = EX(opline);
1006 :
1007 :
1008 : if (IS_VAR == IS_UNUSED) {
1009 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1010 : ZEND_VM_NEXT_OPCODE();
1011 : } else {
1012 : zend_free_op free_op2;
1013 7 : zval *class_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
1014 :
1015 7 : if (IS_VAR != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
1016 2 : EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
1017 5 : } else if (Z_TYPE_P(class_name) == IS_STRING) {
1018 5 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1019 : } else {
1020 0 : zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1021 : }
1022 :
1023 7 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1024 7 : ZEND_VM_NEXT_OPCODE();
1025 : }
1026 : }
1027 :
1028 : static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1029 20 : {
1030 20 : zend_op *opline = EX(opline);
1031 : zval *function_name;
1032 : char *function_name_strval, *lcname;
1033 : int function_name_strlen;
1034 : zend_free_op free_op2;
1035 :
1036 20 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
1037 :
1038 : if (IS_VAR == IS_CONST) {
1039 : if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc)) == FAILURE) {
1040 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
1041 : }
1042 : } else {
1043 20 : function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
1044 :
1045 20 : if (IS_VAR != IS_CONST &&
1046 : Z_TYPE_P(function_name) == IS_OBJECT &&
1047 : Z_OBJ_HANDLER_P(function_name, get_closure) &&
1048 : Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) {
1049 5 : if (EX(object)) {
1050 0 : Z_ADDREF_P(EX(object));
1051 : }
1052 5 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1053 5 : ZEND_VM_NEXT_OPCODE();
1054 : }
1055 :
1056 15 : if (Z_TYPE_P(function_name) != IS_STRING) {
1057 1 : zend_error_noreturn(E_ERROR, "Function name must be a string");
1058 : }
1059 14 : function_name_strval = Z_STRVAL_P(function_name);
1060 14 : function_name_strlen = Z_STRLEN_P(function_name);
1061 14 : if (function_name_strval[0] == '\\') {
1062 :
1063 0 : function_name_strlen -= 1;
1064 0 : lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
1065 : } else {
1066 14 : lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
1067 : }
1068 14 : if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE) {
1069 0 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
1070 : }
1071 14 : efree(lcname);
1072 14 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1073 : }
1074 :
1075 14 : EX(object) = NULL;
1076 14 : ZEND_VM_NEXT_OPCODE();
1077 : }
1078 :
1079 :
1080 : static int ZEND_FASTCALL ZEND_BRK_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1081 0 : {
1082 0 : zend_op *opline = EX(opline);
1083 : zend_free_op free_op2;
1084 : zend_brk_cont_element *el;
1085 :
1086 0 : el = zend_brk_cont(_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
1087 : EX(op_array), EX(Ts) TSRMLS_CC);
1088 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1089 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
1090 : }
1091 :
1092 : static int ZEND_FASTCALL ZEND_CONT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1093 0 : {
1094 0 : zend_op *opline = EX(opline);
1095 : zend_free_op free_op2;
1096 : zend_brk_cont_element *el;
1097 :
1098 0 : el = zend_brk_cont(_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), opline->op1.u.opline_num,
1099 : EX(op_array), EX(Ts) TSRMLS_CC);
1100 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
1101 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
1102 : }
1103 :
1104 : static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1105 2371 : {
1106 2371 : zend_op *opline = EX(opline);
1107 :
1108 :
1109 : if (IS_UNUSED == IS_UNUSED) {
1110 2371 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1111 2371 : ZEND_VM_NEXT_OPCODE();
1112 : } else {
1113 :
1114 : zval *class_name = NULL;
1115 :
1116 : if (IS_UNUSED != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
1117 : EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
1118 : } else if (Z_TYPE_P(class_name) == IS_STRING) {
1119 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1120 : } else {
1121 : zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1122 : }
1123 :
1124 : ZEND_VM_NEXT_OPCODE();
1125 : }
1126 : }
1127 :
1128 : static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1129 1159 : {
1130 1159 : zend_op *opline = EX(opline);
1131 :
1132 :
1133 : if (IS_CV == IS_UNUSED) {
1134 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1135 : ZEND_VM_NEXT_OPCODE();
1136 : } else {
1137 :
1138 1159 : zval *class_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
1139 :
1140 1159 : if (IS_CV != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
1141 17 : EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
1142 1142 : } else if (Z_TYPE_P(class_name) == IS_STRING) {
1143 1141 : EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1144 : } else {
1145 1 : zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1146 : }
1147 :
1148 1154 : ZEND_VM_NEXT_OPCODE();
1149 : }
1150 : }
1151 :
1152 : static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1153 13162 : {
1154 13162 : zend_op *opline = EX(opline);
1155 : zval *function_name;
1156 : char *function_name_strval, *lcname;
1157 : int function_name_strlen;
1158 :
1159 :
1160 13162 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
1161 :
1162 : if (IS_CV == IS_CONST) {
1163 : if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc)) == FAILURE) {
1164 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
1165 : }
1166 : } else {
1167 13162 : function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
1168 :
1169 13162 : if (IS_CV != IS_CONST &&
1170 : Z_TYPE_P(function_name) == IS_OBJECT &&
1171 : Z_OBJ_HANDLER_P(function_name, get_closure) &&
1172 : Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) {
1173 64 : if (EX(object)) {
1174 7 : Z_ADDREF_P(EX(object));
1175 : }
1176 :
1177 64 : ZEND_VM_NEXT_OPCODE();
1178 : }
1179 :
1180 13098 : if (Z_TYPE_P(function_name) != IS_STRING) {
1181 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
1182 : }
1183 13098 : function_name_strval = Z_STRVAL_P(function_name);
1184 13098 : function_name_strlen = Z_STRLEN_P(function_name);
1185 13098 : if (function_name_strval[0] == '\\') {
1186 :
1187 1 : function_name_strlen -= 1;
1188 1 : lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
1189 : } else {
1190 13097 : lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
1191 : }
1192 13098 : if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE) {
1193 1 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
1194 : }
1195 13097 : efree(lcname);
1196 :
1197 : }
1198 :
1199 13097 : EX(object) = NULL;
1200 13097 : ZEND_VM_NEXT_OPCODE();
1201 : }
1202 :
1203 :
1204 : static int ZEND_FASTCALL ZEND_CATCH_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1205 964 : {
1206 964 : zend_op *opline = EX(opline);
1207 : zend_class_entry *ce;
1208 :
1209 : /* Check whether an exception has been thrown, if not, jump over code */
1210 964 : zend_exception_restore(TSRMLS_C);
1211 964 : if (EG(exception) == NULL) {
1212 0 : ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
1213 0 : ZEND_VM_CONTINUE(); /* CHECK_ME */
1214 : }
1215 964 : ce = Z_OBJCE_P(EG(exception));
1216 964 : if (ce != EX_T(opline->op1.u.var).class_entry) {
1217 491 : if (!instanceof_function(ce, EX_T(opline->op1.u.var).class_entry TSRMLS_CC)) {
1218 2 : if (opline->op1.u.EA.type) {
1219 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
1220 0 : ZEND_VM_NEXT_OPCODE();
1221 : }
1222 2 : ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
1223 2 : ZEND_VM_CONTINUE(); /* CHECK_ME */
1224 : }
1225 : }
1226 :
1227 962 : if (!EG(active_symbol_table)) {
1228 126 : if (EX(CVs)[opline->op2.u.var]) {
1229 31 : zval_ptr_dtor(EX(CVs)[opline->op2.u.var]);
1230 : }
1231 126 : EX(CVs)[opline->op2.u.var] = (zval**)EX(CVs) + (EX(op_array)->last_var + opline->op2.u.var);
1232 126 : *EX(CVs)[opline->op2.u.var] = EG(exception);
1233 : } else {
1234 836 : zend_compiled_variable *cv = &CV_DEF_OF(opline->op2.u.var);
1235 836 : zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value,
1236 : &EG(exception), sizeof(zval *), (void**)&EX(CVs)[opline->op2.u.var]);
1237 : }
1238 962 : EG(exception) = NULL;
1239 962 : ZEND_VM_NEXT_OPCODE();
1240 : }
1241 :
1242 : static int ZEND_FASTCALL ZEND_BRK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1243 0 : {
1244 0 : zend_op *opline = EX(opline);
1245 :
1246 : zend_brk_cont_element *el;
1247 :
1248 0 : el = zend_brk_cont(_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC), opline->op1.u.opline_num,
1249 : EX(op_array), EX(Ts) TSRMLS_CC);
1250 :
1251 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
1252 : }
1253 :
1254 : static int ZEND_FASTCALL ZEND_CONT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1255 0 : {
1256 0 : zend_op *opline = EX(opline);
1257 :
1258 : zend_brk_cont_element *el;
1259 :
1260 0 : el = zend_brk_cont(_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC), opline->op1.u.opline_num,
1261 : EX(op_array), EX(Ts) TSRMLS_CC);
1262 :
1263 0 : ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
1264 : }
1265 :
1266 : static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1267 78 : {
1268 78 : zend_op *opline = EX(opline);
1269 :
1270 :
1271 78 : bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
1272 : &opline->op1.u.constant TSRMLS_CC);
1273 :
1274 78 : ZEND_VM_NEXT_OPCODE();
1275 : }
1276 :
1277 : static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1278 20031 : {
1279 20031 : zend_op *opline = EX(opline);
1280 :
1281 :
1282 20031 : boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
1283 : &opline->op1.u.constant TSRMLS_CC);
1284 :
1285 20031 : ZEND_VM_NEXT_OPCODE();
1286 : }
1287 :
1288 : static int ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1289 40214 : {
1290 40214 : zend_op *opline = EX(opline);
1291 :
1292 : zval z_copy;
1293 40214 : zval *z = &opline->op1.u.constant;
1294 :
1295 : if (IS_CONST != IS_CONST &&
1296 : Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
1297 : zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
1298 : zend_print_variable(&z_copy);
1299 : zval_dtor(&z_copy);
1300 : } else {
1301 40214 : zend_print_variable(z);
1302 : }
1303 :
1304 40213 : ZEND_VM_NEXT_OPCODE();
1305 : }
1306 :
1307 : static int ZEND_FASTCALL ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1308 1462 : {
1309 1462 : zend_op *opline = EX(opline);
1310 :
1311 1462 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
1312 1462 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
1313 :
1314 1462 : return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1315 : }
1316 :
1317 : static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
1318 1559116 : {
1319 1559116 : zend_op *opline = EX(opline);
1320 : zend_free_op free_op1;
1321 1559116 : zval *varname = &opline->op1.u.constant;
1322 : zval **retval;
1323 : zval tmp_varname;
1324 : HashTable *target_symbol_table;
1325 :
1326 : if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
1327 : tmp_varname = *varname;
1328 : zval_copy_ctor(&tmp_varname);
1329 : convert_to_string(&tmp_varname);
1330 : varname = &tmp_varname;
1331 : }
1332 :
1333 1559116 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
1334 740 : retval = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0 TSRMLS_CC);
1335 :
1336 : } else {
1337 1558376 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
1338 : /*
1339 : if (!target_symbol_table) {
1340 : ZEND_VM_NEXT_OPCODE();
1341 : }
1342 : */
1343 1558376 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
1344 1818 : switch (type) {
1345 : case BP_VAR_R:
1346 : case BP_VAR_UNSET:
1347 1551 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
1348 : /* break missing intentionally */
1349 : case BP_VAR_IS:
1350 1551 : retval = &EG(uninitialized_zval_ptr);
1351 1551 : break;
1352 : case BP_VAR_RW:
1353 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
1354 : /* break missing intentionally */
1355 : case BP_VAR_W: {
1356 267 : zval *new_zval = &EG(uninitialized_zval);
1357 :
1358 267 : Z_ADDREF_P(new_zval);
1359 267 : zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
1360 : }
1361 : break;
1362 : EMPTY_SWITCH_DEFAULT_CASE()
1363 : }
1364 : }
1365 1558376 : switch (opline->op2.u.EA.type) {
1366 : case ZEND_FETCH_GLOBAL:
1367 : if (IS_CONST != IS_TMP_VAR) {
1368 :
1369 : }
1370 13774 : break;
1371 : case ZEND_FETCH_LOCAL:
1372 :
1373 1002217 : break;
1374 : case ZEND_FETCH_STATIC:
1375 1298 : zval_update_constant(retval, (void*) 1 TSRMLS_CC);
1376 : break;
1377 : case ZEND_FETCH_GLOBAL_LOCK:
1378 : if (IS_CONST == IS_VAR && !free_op1.var) {
1379 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
1380 : }
1381 : break;
1382 : }
1383 : }
1384 :
1385 :
1386 : if (IS_CONST != IS_CONST && varname == &tmp_varname) {
1387 : zval_dtor(varname);
1388 : }
1389 1559106 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
1390 1559102 : if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
1391 2 : SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
1392 : }
1393 1559102 : PZVAL_LOCK(*retval);
1394 1559102 : switch (type) {
1395 : case BP_VAR_R:
1396 : case BP_VAR_IS:
1397 304193 : AI_SET_PTR(EX_T(opline->result.u.var).var, *retval);
1398 304193 : break;
1399 : case BP_VAR_UNSET: {
1400 : zend_free_op free_res;
1401 :
1402 34 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
1403 34 : PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
1404 34 : if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
1405 34 : SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
1406 : }
1407 34 : PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
1408 34 : FREE_OP_VAR_PTR(free_res);
1409 34 : break;
1410 : default:
1411 1254875 : EX_T(opline->result.u.var).var.ptr_ptr = retval;
1412 : break;
1413 : }
1414 : }
1415 : }
1416 1559106 : ZEND_VM_NEXT_OPCODE();
1417 : }
1418 :
1419 : static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1420 304136 : {
1421 304136 : return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1422 : }
1423 :
1424 : static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1425 1254814 : {
1426 1254814 : return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1427 : }
1428 :
1429 : static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1430 67 : {
1431 67 : return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1432 : }
1433 :
1434 : static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1435 43 : {
1436 43 : return zend_fetch_var_address_helper_SPEC_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), EX(opline)->extended_value)?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1437 : }
1438 :
1439 : static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1440 34 : {
1441 34 : return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1442 : }
1443 :
1444 : static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1445 22 : {
1446 22 : return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1447 : }
1448 :
1449 : static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1450 744261 : {
1451 744261 : zend_op *opline = EX(opline);
1452 :
1453 744261 : zval *val = &opline->op1.u.constant;
1454 : int ret;
1455 :
1456 : if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
1457 : ret = Z_LVAL_P(val);
1458 : } else {
1459 744261 : ret = i_zend_is_true(val);
1460 :
1461 744260 : if (UNEXPECTED(EG(exception) != NULL)) {
1462 0 : ZEND_VM_CONTINUE();
1463 : }
1464 : }
1465 744260 : if (!ret) {
1466 : #if DEBUG_ZEND>=2
1467 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1468 : #endif
1469 107 : ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
1470 107 : ZEND_VM_CONTINUE();
1471 : }
1472 :
1473 744153 : ZEND_VM_NEXT_OPCODE();
1474 : }
1475 :
1476 : static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1477 10 : {
1478 10 : zend_op *opline = EX(opline);
1479 :
1480 10 : zval *val = &opline->op1.u.constant;
1481 : int ret;
1482 :
1483 : if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
1484 : ret = Z_LVAL_P(val);
1485 : } else {
1486 10 : ret = i_zend_is_true(val);
1487 :
1488 10 : if (UNEXPECTED(EG(exception) != NULL)) {
1489 0 : ZEND_VM_CONTINUE();
1490 : }
1491 : }
1492 10 : if (ret) {
1493 : #if DEBUG_ZEND>=2
1494 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1495 : #endif
1496 7 : ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
1497 7 : ZEND_VM_CONTINUE();
1498 : }
1499 :
1500 3 : ZEND_VM_NEXT_OPCODE();
1501 : }
1502 :
1503 : static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1504 527841 : {
1505 527841 : zend_op *opline = EX(opline);
1506 :
1507 527841 : zval *val = &opline->op1.u.constant;
1508 : int retval;
1509 :
1510 : if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
1511 : retval = Z_LVAL_P(val);
1512 : } else {
1513 527841 : retval = i_zend_is_true(val);
1514 :
1515 527841 : if (UNEXPECTED(EG(exception) != NULL)) {
1516 0 : ZEND_VM_CONTINUE();
1517 : }
1518 : }
1519 527841 : if (EXPECTED(retval != 0)) {
1520 : #if DEBUG_ZEND>=2
1521 : printf("Conditional jmp on true to %d\n", opline->extended_value);
1522 : #endif
1523 527841 : ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
1524 527841 : ZEND_VM_CONTINUE(); /* CHECK_ME */
1525 : } else {
1526 : #if DEBUG_ZEND>=2
1527 : printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
1528 : #endif
1529 0 : ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.u.opline_num]);
1530 0 : ZEND_VM_CONTINUE(); /* CHECK_ME */
1531 : }
1532 : }
1533 :
1534 : static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1535 0 : {
1536 0 : zend_op *opline = EX(opline);
1537 :
1538 0 : zval *val = &opline->op1.u.constant;
1539 : int retval;
1540 :
1541 : if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
1542 : retval = Z_LVAL_P(val);
1543 : } else {
1544 0 : retval = i_zend_is_true(val);
1545 :
1546 0 : if (UNEXPECTED(EG(exception) != NULL)) {
1547 0 : ZEND_VM_CONTINUE();
1548 : }
1549 : }
1550 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
1551 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
1552 0 : if (!retval) {
1553 : #if DEBUG_ZEND>=2
1554 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1555 : #endif
1556 0 : ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
1557 0 : ZEND_VM_CONTINUE();
1558 : }
1559 0 : ZEND_VM_NEXT_OPCODE();
1560 : }
1561 :
1562 : static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1563 0 : {
1564 0 : zend_op *opline = EX(opline);
1565 :
1566 0 : zval *val = &opline->op1.u.constant;
1567 : int retval;
1568 :
1569 : if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
1570 : retval = Z_LVAL_P(val);
1571 : } else {
1572 0 : retval = i_zend_is_true(val);
1573 :
1574 0 : if (UNEXPECTED(EG(exception) != NULL)) {
1575 0 : ZEND_VM_CONTINUE();
1576 : }
1577 : }
1578 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
1579 0 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
1580 0 : if (retval) {
1581 : #if DEBUG_ZEND>=2
1582 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
1583 : #endif
1584 0 : ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
1585 0 : ZEND_VM_CONTINUE();
1586 : }
1587 0 : ZEND_VM_NEXT_OPCODE();
1588 : }
1589 :
1590 : static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1591 15985550 : {
1592 15985550 : zend_op *opline = EX(opline);
1593 :
1594 15985550 : zval *fname = &opline->op1.u.constant;
1595 :
1596 15985550 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
1597 :
1598 15985549 : if (zend_hash_quick_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, Z_LVAL(opline->op2.u.constant), (void **) &EX(function_state).function)==FAILURE) {
1599 0 : zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
1600 : }
1601 15985549 : EX(object) = NULL;
1602 :
1603 15985549 : return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1604 : }
1605 :
1606 : static int ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1607 269912 : {
1608 269912 : zend_op *opline = EX(opline);
1609 : zval *retval_ptr;
1610 : zval **retval_ptr_ptr;
1611 :
1612 :
1613 269912 : if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
1614 :
1615 : if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
1616 : /* Not supposed to happen, but we'll allow it */
1617 6 : zend_error(E_NOTICE, "Only variable references should be returned by reference");
1618 6 : goto return_by_value;
1619 : }
1620 :
1621 : retval_ptr_ptr = NULL;
1622 :
1623 : if (IS_CONST == IS_VAR && !retval_ptr_ptr) {
1624 : zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
1625 : }
1626 :
1627 : if (IS_CONST == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
1628 : if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
1629 : EX_T(opline->op1.u.var).var.fcall_returned_reference) {
1630 : } else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
1631 : if (IS_CONST == IS_VAR && !0) {
1632 : PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
1633 : }
1634 : zend_error(E_NOTICE, "Only variable references should be returned by reference");
1635 : goto return_by_value;
1636 : }
1637 : }
1638 :
1639 : if (EG(return_value_ptr_ptr)) {
1640 : SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
1641 : Z_ADDREF_PP(retval_ptr_ptr);
1642 :
1643 : (*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
1644 : }
1645 : } else {
1646 269912 : return_by_value:
1647 :
1648 269912 : retval_ptr = &opline->op1.u.constant;
1649 :
1650 269912 : if (!EG(return_value_ptr_ptr)) {
1651 : if (IS_CONST == IS_TMP_VAR) {
1652 :
1653 : }
1654 : } else if (!0) { /* Not a temp var */
1655 : if (IS_CONST == IS_CONST ||
1656 : EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
1657 : (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
1658 : zval *ret;
1659 :
1660 124618 : ALLOC_ZVAL(ret);
1661 124618 : INIT_PZVAL_COPY(ret, retval_ptr);
1662 124618 : zval_copy_ctor(ret);
1663 124618 : *EG(return_value_ptr_ptr) = ret;
1664 : } else {
1665 : *EG(return_value_ptr_ptr) = retval_ptr;
1666 : Z_ADDREF_P(retval_ptr);
1667 : }
1668 : } else {
1669 : zval *ret;
1670 :
1671 : ALLOC_ZVAL(ret);
1672 : INIT_PZVAL_COPY(ret, retval_ptr);
1673 : *EG(return_value_ptr_ptr) = ret;
1674 : }
1675 : }
1676 :
1677 269912 : return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1678 : }
1679 :
1680 : static int ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1681 2 : {
1682 2 : zend_op *opline = EX(opline);
1683 : zval *value;
1684 : zval *exception;
1685 :
1686 :
1687 2 : value = &opline->op1.u.constant;
1688 :
1689 : if (IS_CONST == IS_CONST || Z_TYPE_P(value) != IS_OBJECT) {
1690 2 : zend_error_noreturn(E_ERROR, "Can only throw objects");
1691 : }
1692 : zend_exception_save(TSRMLS_C);
1693 : /* Not sure if a complete copy is what we want here */
1694 : ALLOC_ZVAL(exception);
1695 : INIT_PZVAL_COPY(exception, value);
1696 : if (!0) {
1697 : zval_copy_ctor(exception);
1698 : }
1699 :
1700 : zend_throw_exception_object(exception TSRMLS_CC);
1701 : zend_exception_restore(TSRMLS_C);
1702 :
1703 : ZEND_VM_NEXT_OPCODE();
1704 : }
1705 :
1706 : static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1707 6953745 : {
1708 6953745 : zend_op *opline = EX(opline);
1709 6953745 : if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
1710 : && ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
1711 2 : zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
1712 : }
1713 : {
1714 : zval *valptr;
1715 : zval *value;
1716 :
1717 :
1718 6953743 : value = &opline->op1.u.constant;
1719 :
1720 6953743 : ALLOC_ZVAL(valptr);
1721 6953743 : INIT_PZVAL_COPY(valptr, value);
1722 : if (!0) {
1723 6953743 : zval_copy_ctor(valptr);
1724 : }
1725 6953743 : zend_vm_stack_push(valptr TSRMLS_CC);
1726 :
1727 : }
1728 6953743 : ZEND_VM_NEXT_OPCODE();
1729 : }
1730 :
1731 : static int ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1732 1 : {
1733 1 : zend_op *opline = EX(opline);
1734 :
1735 :
1736 : /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
1737 1 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = i_zend_is_true(&opline->op1.u.constant);
1738 1 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
1739 :
1740 1 : ZEND_VM_NEXT_OPCODE();
1741 : }
1742 :
1743 : static int ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1744 2 : {
1745 2 : zend_op *opline = EX(opline);
1746 :
1747 2 : zval *obj = &opline->op1.u.constant;
1748 : zend_class_entry *ce;
1749 : zend_function *clone;
1750 : zend_object_clone_obj_t clone_call;
1751 :
1752 : if (IS_CONST == IS_CONST ||
1753 : (IS_CONST == IS_VAR && !obj) ||
1754 : Z_TYPE_P(obj) != IS_OBJECT) {
1755 2 : zend_error_noreturn(E_ERROR, "__clone method called on non-object");
1756 : }
1757 :
1758 : ce = Z_OBJCE_P(obj);
1759 : clone = ce ? ce->clone : NULL;
1760 : clone_call = Z_OBJ_HT_P(obj)->clone_obj;
1761 : if (!clone_call) {
1762 : if (ce) {
1763 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
1764 : } else {
1765 : zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
1766 : }
1767 : }
1768 :
1769 : if (ce && clone) {
1770 : if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
1771 : /* Ensure that if we're calling a private function, we're allowed to do so.
1772 : */
1773 : if (ce != EG(scope)) {
1774 : zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
1775 : }
1776 : } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
1777 : /* Ensure that if we're calling a protected function, we're allowed to do so.
1778 : */
1779 : if (!zend_check_protected(clone->common.scope, EG(scope))) {
1780 : zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
1781 : }
1782 : }
1783 : }
1784 :
1785 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
1786 : if (!EG(exception)) {
1787 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
1788 : Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
1789 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
1790 : Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
1791 : Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
1792 : if (!RETURN_VALUE_USED(opline) || EG(exception)) {
1793 : zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
1794 : }
1795 : }
1796 :
1797 : ZEND_VM_NEXT_OPCODE();
1798 : }
1799 :
1800 : static int ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1801 225 : {
1802 225 : zend_op *opline = EX(opline);
1803 :
1804 225 : zval *expr = &opline->op1.u.constant;
1805 225 : zval *result = &EX_T(opline->result.u.var).tmp_var;
1806 :
1807 225 : if (opline->extended_value != IS_STRING) {
1808 20 : *result = *expr;
1809 : if (!0) {
1810 20 : zendi_zval_copy_ctor(*result);
1811 : }
1812 : }
1813 225 : switch (opline->extended_value) {
1814 : case IS_NULL:
1815 0 : convert_to_null(result);
1816 0 : break;
1817 : case IS_BOOL:
1818 2 : convert_to_boolean(result);
1819 2 : break;
1820 : case IS_LONG:
1821 5 : convert_to_long(result);
1822 5 : break;
1823 : case IS_DOUBLE:
1824 8 : convert_to_double(result);
1825 8 : break;
1826 : case IS_STRING: {
1827 : zval var_copy;
1828 : int use_copy;
1829 :
1830 205 : zend_make_printable_zval(expr, &var_copy, &use_copy);
1831 205 : if (use_copy) {
1832 9 : *result = var_copy;
1833 : if (0) {
1834 :
1835 : }
1836 : } else {
1837 196 : *result = *expr;
1838 : if (!0) {
1839 196 : zendi_zval_copy_ctor(*result);
1840 : }
1841 : }
1842 205 : break;
1843 : }
1844 : case IS_ARRAY:
1845 3 : convert_to_array(result);
1846 3 : break;
1847 : case IS_OBJECT:
1848 2 : convert_to_object(result);
1849 : break;
1850 : }
1851 :
1852 225 : ZEND_VM_NEXT_OPCODE();
1853 : }
1854 :
1855 : static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1856 5785 : {
1857 5785 : zend_op *opline = EX(opline);
1858 5785 : zend_op_array *new_op_array=NULL;
1859 : int return_value_used;
1860 :
1861 5785 : zval *inc_filename = &opline->op1.u.constant;
1862 : zval tmp_inc_filename;
1863 5785 : zend_bool failure_retval=0;
1864 :
1865 5785 : if (inc_filename->type!=IS_STRING) {
1866 0 : tmp_inc_filename = *inc_filename;
1867 0 : zval_copy_ctor(&tmp_inc_filename);
1868 0 : convert_to_string(&tmp_inc_filename);
1869 0 : inc_filename = &tmp_inc_filename;
1870 : }
1871 :
1872 5785 : return_value_used = RETURN_VALUE_USED(opline);
1873 :
1874 5785 : switch (Z_LVAL(opline->op2.u.constant)) {
1875 : case ZEND_INCLUDE_ONCE:
1876 : case ZEND_REQUIRE_ONCE: {
1877 : zend_file_handle file_handle;
1878 : char *resolved_path;
1879 :
1880 4004 : resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
1881 4004 : if (resolved_path) {
1882 3999 : failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
1883 : } else {
1884 5 : resolved_path = Z_STRVAL_P(inc_filename);
1885 : }
1886 :
1887 4004 : if (failure_retval) {
1888 : /* do nothing, file already included */
1889 3394 : } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
1890 :
1891 3391 : if (!file_handle.opened_path) {
1892 4 : file_handle.opened_path = estrdup(resolved_path);
1893 : }
1894 :
1895 3391 : if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
1896 3390 : new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
1897 3390 : zend_destroy_file_handle(&file_handle TSRMLS_CC);
1898 : } else {
1899 1 : zend_file_handle_dtor(&file_handle TSRMLS_CC);
1900 1 : failure_retval=1;
1901 : }
1902 : } else {
1903 3 : if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
1904 0 : zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
1905 : } else {
1906 3 : zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
1907 : }
1908 : }
1909 4001 : if (resolved_path != Z_STRVAL_P(inc_filename)) {
1910 3999 : efree(resolved_path);
1911 : }
1912 : }
1913 4001 : break;
1914 : case ZEND_INCLUDE:
1915 : case ZEND_REQUIRE:
1916 1744 : new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
1917 1742 : break;
1918 : case ZEND_EVAL: {
1919 37 : char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
1920 :
1921 37 : new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
1922 36 : efree(eval_desc);
1923 : }
1924 : break;
1925 : EMPTY_SWITCH_DEFAULT_CASE()
1926 : }
1927 5779 : if (inc_filename==&tmp_inc_filename) {
1928 0 : zval_dtor(&tmp_inc_filename);
1929 : }
1930 :
1931 5779 : EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
1932 5779 : if (new_op_array && !EG(exception)) {
1933 5159 : EX(original_return_value) = EG(return_value_ptr_ptr);
1934 5159 : EG(return_value_ptr_ptr) = return_value_used ? EX_T(opline->result.u.var).var.ptr_ptr : NULL;
1935 5159 : EG(active_op_array) = new_op_array;
1936 5159 : EX_T(opline->result.u.var).var.ptr = NULL;
1937 :
1938 5159 : EX(current_object) = EX(object);
1939 :
1940 5159 : EX(function_state).function = (zend_function *) new_op_array;
1941 5159 : EX(object) = NULL;
1942 :
1943 5159 : if (!EG(active_symbol_table)) {
1944 15 : zend_rebuild_symbol_table(TSRMLS_C);
1945 : }
1946 :
1947 5159 : if (zend_execute == execute) {
1948 5159 : EX(call_opline) = opline;
1949 5159 : ZEND_VM_ENTER();
1950 : } else {
1951 0 : zend_execute(new_op_array TSRMLS_CC);
1952 : }
1953 :
1954 0 : EX(function_state).function = (zend_function *) EX(op_array);
1955 0 : EX(object) = EX(current_object);
1956 :
1957 0 : if (return_value_used) {
1958 0 : if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
1959 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
1960 0 : INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
1961 0 : Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
1962 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
1963 : }
1964 : }
1965 :
1966 0 : EG(opline_ptr) = &EX(opline);
1967 0 : EG(active_op_array) = EX(op_array);
1968 0 : EG(return_value_ptr_ptr) = EX(original_return_value);
1969 0 : destroy_op_array(new_op_array TSRMLS_CC);
1970 0 : efree(new_op_array);
1971 0 : if (EG(exception)) {
1972 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
1973 : }
1974 : } else {
1975 620 : if (return_value_used) {
1976 0 : ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
1977 0 : INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
1978 0 : Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
1979 0 : Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
1980 : }
1981 : }
1982 620 : ZEND_VM_NEXT_OPCODE();
1983 : }
1984 :
1985 : static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1986 4 : {
1987 4 : zend_op *opline = EX(opline);
1988 : zval tmp, *varname;
1989 : HashTable *target_symbol_table;
1990 :
1991 :
1992 : if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
1993 : if (EG(active_symbol_table)) {
1994 : zend_execute_data *ex = EX(prev_execute_data);
1995 : zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
1996 :
1997 : if (zend_hash_quick_del(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value) == SUCCESS) {
1998 : while (ex && ex->symbol_table == EG(active_symbol_table)) {
1999 : int i;
2000 :
2001 : if (ex->op_array) {
2002 : for (i = 0; i < ex->op_array->last_var; i++) {
2003 : if (ex->op_array->vars[i].hash_value == cv->hash_value &&
2004 : ex->op_array->vars[i].name_len == cv->name_len &&
2005 : !memcmp(ex->op_array->vars[i].name, cv->name, cv->name_len)) {
2006 : ex->CVs[i] = NULL;
2007 : break;
2008 : }
2009 : }
2010 : }
2011 : ex = ex->prev_execute_data;
2012 : }
2013 : }
2014 : EX(CVs)[opline->op1.u.var] = NULL;
2015 : } else if (EX(CVs)[opline->op1.u.var]) {
2016 : zval_ptr_dtor(EX(CVs)[opline->op1.u.var]);
2017 : EX(CVs)[opline->op1.u.var] = NULL;
2018 : }
2019 : ZEND_VM_NEXT_OPCODE();
2020 : }
2021 :
2022 4 : varname = &opline->op1.u.constant;
2023 :
2024 4 : if (Z_TYPE_P(varname) != IS_STRING) {
2025 0 : tmp = *varname;
2026 0 : zval_copy_ctor(&tmp);
2027 0 : convert_to_string(&tmp);
2028 0 : varname = &tmp;
2029 : } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
2030 : Z_ADDREF_P(varname);
2031 : }
2032 :
2033 4 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
2034 0 : zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
2035 : } else {
2036 4 : ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
2037 :
2038 4 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
2039 4 : if (zend_hash_quick_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value) == SUCCESS) {
2040 4 : zend_execute_data *ex = execute_data;
2041 :
2042 : do {
2043 : int i;
2044 :
2045 6 : if (ex->op_array) {
2046 6 : for (i = 0; i < ex->op_array->last_var; i++) {
2047 0 : if (ex->op_array->vars[i].hash_value == hash_value &&
2048 : ex->op_array->vars[i].name_len == varname->value.str.len &&
2049 : !memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
2050 0 : ex->CVs[i] = NULL;
2051 0 : break;
2052 : }
2053 : }
2054 : }
2055 6 : ex = ex->prev_execute_data;
2056 6 : } while (ex && ex->symbol_table == target_symbol_table);
2057 : }
2058 : }
2059 :
2060 4 : if (varname == &tmp) {
2061 0 : zval_dtor(&tmp);
2062 : } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
2063 : zval_ptr_dtor(&varname);
2064 : }
2065 :
2066 4 : ZEND_VM_NEXT_OPCODE();
2067 : }
2068 :
2069 : static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2070 0 : {
2071 0 : zend_op *opline = EX(opline);
2072 :
2073 : zval *array_ptr, **array_ptr_ptr;
2074 : HashTable *fe_ht;
2075 0 : zend_object_iterator *iter = NULL;
2076 0 : zend_class_entry *ce = NULL;
2077 0 : zend_bool is_empty = 0;
2078 :
2079 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2080 0 : array_ptr_ptr = NULL;
2081 0 : if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
2082 0 : ALLOC_INIT_ZVAL(array_ptr);
2083 0 : } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
2084 0 : if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
2085 0 : zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
2086 0 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
2087 : }
2088 :
2089 0 : ce = Z_OBJCE_PP(array_ptr_ptr);
2090 0 : if (!ce || ce->get_iterator == NULL) {
2091 0 : SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
2092 0 : Z_ADDREF_PP(array_ptr_ptr);
2093 : }
2094 0 : array_ptr = *array_ptr_ptr;
2095 : } else {
2096 0 : if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
2097 0 : SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
2098 0 : if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
2099 0 : Z_SET_ISREF_PP(array_ptr_ptr);
2100 : }
2101 : }
2102 0 : array_ptr = *array_ptr_ptr;
2103 0 : Z_ADDREF_P(array_ptr);
2104 : }
2105 : } else {
2106 0 : array_ptr = &opline->op1.u.constant;
2107 : if (0) { /* IS_TMP_VAR */
2108 : zval *tmp;
2109 :
2110 : ALLOC_ZVAL(tmp);
2111 : INIT_PZVAL_COPY(tmp, array_ptr);
2112 : array_ptr = tmp;
2113 : if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
2114 : ce = Z_OBJCE_P(array_ptr);
2115 : if (ce && ce->get_iterator) {
2116 : Z_DELREF_P(array_ptr);
2117 : }
2118 : }
2119 0 : } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
2120 0 : ce = Z_OBJCE_P(array_ptr);
2121 0 : if (!ce || !ce->get_iterator) {
2122 0 : Z_ADDREF_P(array_ptr);
2123 : }
2124 : } else if (IS_CONST == IS_CONST ||
2125 : ((IS_CONST == IS_CV || IS_CONST == IS_VAR) &&
2126 : !Z_ISREF_P(array_ptr) &&
2127 : Z_REFCOUNT_P(array_ptr) > 1)) {
2128 : zval *tmp;
2129 :
2130 0 : ALLOC_ZVAL(tmp);
2131 0 : INIT_PZVAL_COPY(tmp, array_ptr);
2132 0 : zval_copy_ctor(tmp);
2133 0 : array_ptr = tmp;
2134 : } else {
2135 : Z_ADDREF_P(array_ptr);
2136 : }
2137 : }
2138 :
2139 0 : if (ce && ce->get_iterator) {
2140 0 : iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
2141 :
2142 0 : if (iter && !EG(exception)) {
2143 0 : array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
2144 : } else {
2145 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2146 :
2147 : } else {
2148 :
2149 : }
2150 0 : if (!EG(exception)) {
2151 0 : zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
2152 : }
2153 0 : zend_throw_exception_internal(NULL TSRMLS_CC);
2154 0 : ZEND_VM_NEXT_OPCODE();
2155 : }
2156 : }
2157 :
2158 0 : AI_SET_PTR(EX_T(opline->result.u.var).var, array_ptr);
2159 0 : PZVAL_LOCK(array_ptr);
2160 :
2161 0 : if (iter) {
2162 0 : iter->index = 0;
2163 0 : if (iter->funcs->rewind) {
2164 0 : iter->funcs->rewind(iter TSRMLS_CC);
2165 0 : if (EG(exception)) {
2166 0 : Z_DELREF_P(array_ptr);
2167 0 : zval_ptr_dtor(&array_ptr);
2168 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2169 :
2170 : } else {
2171 :
2172 : }
2173 0 : ZEND_VM_NEXT_OPCODE();
2174 : }
2175 : }
2176 0 : is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
2177 0 : if (EG(exception)) {
2178 0 : Z_DELREF_P(array_ptr);
2179 0 : zval_ptr_dtor(&array_ptr);
2180 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2181 :
2182 : } else {
2183 :
2184 : }
2185 0 : ZEND_VM_NEXT_OPCODE();
2186 : }
2187 0 : iter->index = -1; /* will be set to 0 before using next handler */
2188 0 : } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
2189 0 : zend_hash_internal_pointer_reset(fe_ht);
2190 0 : if (ce) {
2191 0 : zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
2192 0 : while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
2193 : char *str_key;
2194 : uint str_key_len;
2195 : ulong int_key;
2196 : zend_uchar key_type;
2197 :
2198 0 : key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
2199 0 : if (key_type != HASH_KEY_NON_EXISTANT &&
2200 : (key_type == HASH_KEY_IS_LONG ||
2201 : zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
2202 : break;
2203 : }
2204 0 : zend_hash_move_forward(fe_ht);
2205 : }
2206 : }
2207 0 : is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
2208 0 : zend_hash_get_pointer(fe_ht, &EX_T(opline->result.u.var).fe.fe_pos);
2209 : } else {
2210 0 : zend_error(E_WARNING, "Invalid argument supplied for foreach()");
2211 0 : is_empty = 1;
2212 : }
2213 :
2214 0 : if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
2215 :
2216 : } else {
2217 :
2218 : }
2219 0 : if (is_empty) {
2220 0 : ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
2221 : } else {
2222 0 : ZEND_VM_NEXT_OPCODE();
2223 : }
2224 : }
2225 :
2226 : static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2227 14 : {
2228 14 : zend_op *opline = EX(opline);
2229 : zval **value;
2230 14 : zend_bool isset = 1;
2231 :
2232 : if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
2233 : if (EX(CVs)[opline->op1.u.var]) {
2234 : value = EX(CVs)[opline->op1.u.var];
2235 : } else if (EG(active_symbol_table)) {
2236 : zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
2237 :
2238 : if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
2239 : isset = 0;
2240 : }
2241 : } else {
2242 : isset = 0;
2243 : }
2244 : } else {
2245 : HashTable *target_symbol_table;
2246 :
2247 14 : zval tmp, *varname = &opline->op1.u.constant;
2248 :
2249 14 : if (Z_TYPE_P(varname) != IS_STRING) {
2250 0 : tmp = *varname;
2251 0 : zval_copy_ctor(&tmp);
2252 0 : convert_to_string(&tmp);
2253 0 : varname = &tmp;
2254 : }
2255 :
2256 14 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
2257 4 : value = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1 TSRMLS_CC);
2258 4 : if (!value) {
2259 1 : isset = 0;
2260 : }
2261 : } else {
2262 10 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
2263 10 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
2264 0 : isset = 0;
2265 : }
2266 : }
2267 :
2268 14 : if (varname == &tmp) {
2269 0 : zval_dtor(&tmp);
2270 : }
2271 :
2272 : }
2273 :
2274 14 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
2275 :
2276 14 : switch (opline->extended_value & ZEND_ISSET_ISEMPTY_MASK) {
2277 : case ZEND_ISSET:
2278 11 : if (isset && Z_TYPE_PP(value) == IS_NULL) {
2279 1 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
2280 : } else {
2281 9 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
2282 : }
2283 10 : break;
2284 : case ZEND_ISEMPTY:
2285 4 : if (!isset || !i_zend_is_true(*value)) {
2286 0 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
2287 : } else {
2288 4 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
2289 : }
2290 : break;
2291 : }
2292 :
2293 14 : ZEND_VM_NEXT_OPCODE();
2294 : }
2295 :
2296 : static int ZEND_FASTCALL ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2297 624 : {
2298 : #if 0 || (IS_CONST != IS_UNUSED)
2299 624 : zend_op *opline = EX(opline);
2300 : if (IS_CONST != IS_UNUSED) {
2301 :
2302 624 : zval *ptr = &opline->op1.u.constant;
2303 :
2304 624 : if (Z_TYPE_P(ptr) == IS_LONG) {
2305 29 : EG(exit_status) = Z_LVAL_P(ptr);
2306 : } else {
2307 595 : zend_print_variable(ptr);
2308 : }
2309 :
2310 : }
2311 : #endif
2312 624 : zend_bailout();
2313 0 : ZEND_VM_NEXT_OPCODE();
2314 : }
2315 :
2316 : static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2317 5 : {
2318 5 : zend_op *opline = EX(opline);
2319 :
2320 5 : zval *value = &opline->op1.u.constant;
2321 :
2322 5 : if (i_zend_is_true(value)) {
2323 3 : EX_T(opline->result.u.var).tmp_var = *value;
2324 3 : zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
2325 :
2326 : #if DEBUG_ZEND>=2
2327 : printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
2328 : #endif
2329 3 : ZEND_VM_JMP(opline->op2.u.jmp_addr);
2330 : }
2331 :
2332 2 : ZEND_VM_NEXT_OPCODE();
2333 : }
2334 :
2335 : static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2336 592813 : {
2337 592813 : zend_op *opline = EX(opline);
2338 :
2339 592813 : zval *value = &opline->op1.u.constant;
2340 :
2341 592813 : EX_T(opline->result.u.var).tmp_var = *value;
2342 : if (!0) {
2343 592813 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
2344 : }
2345 :
2346 592813 : ZEND_VM_NEXT_OPCODE();
2347 : }
2348 :
2349 : static int ZEND_FASTCALL ZEND_TICKS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2350 38 : {
2351 38 : zend_op *opline = EX(opline);
2352 :
2353 38 : if (++EG(ticks_count)>=Z_LVAL(opline->op1.u.constant)) {
2354 38 : EG(ticks_count)=0;
2355 38 : if (zend_ticks_function) {
2356 38 : zend_ticks_function(Z_LVAL(opline->op1.u.constant));
2357 : }
2358 : }
2359 38 : ZEND_VM_NEXT_OPCODE();
2360 : }
2361 :
2362 : static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2363 1266 : {
2364 1266 : zend_op *opline = EX(opline);
2365 :
2366 :
2367 1266 : add_function(&EX_T(opline->result.u.var).tmp_var,
2368 : &opline->op1.u.constant,
2369 : &opline->op2.u.constant TSRMLS_CC);
2370 :
2371 :
2372 1266 : ZEND_VM_NEXT_OPCODE();
2373 : }
2374 :
2375 : static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2376 111 : {
2377 111 : zend_op *opline = EX(opline);
2378 :
2379 :
2380 111 : sub_function(&EX_T(opline->result.u.var).tmp_var,
2381 : &opline->op1.u.constant,
2382 : &opline->op2.u.constant TSRMLS_CC);
2383 :
2384 :
2385 111 : ZEND_VM_NEXT_OPCODE();
2386 : }
2387 :
2388 : static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2389 8234 : {
2390 8234 : zend_op *opline = EX(opline);
2391 :
2392 :
2393 8234 : mul_function(&EX_T(opline->result.u.var).tmp_var,
2394 : &opline->op1.u.constant,
2395 : &opline->op2.u.constant TSRMLS_CC);
2396 :
2397 :
2398 8234 : ZEND_VM_NEXT_OPCODE();
2399 : }
2400 :
2401 : static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2402 36 : {
2403 36 : zend_op *opline = EX(opline);
2404 :
2405 :
2406 36 : div_function(&EX_T(opline->result.u.var).tmp_var,
2407 : &opline->op1.u.constant,
2408 : &opline->op2.u.constant TSRMLS_CC);
2409 :
2410 :
2411 36 : ZEND_VM_NEXT_OPCODE();
2412 : }
2413 :
2414 : static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2415 4 : {
2416 4 : zend_op *opline = EX(opline);
2417 :
2418 :
2419 4 : mod_function(&EX_T(opline->result.u.var).tmp_var,
2420 : &opline->op1.u.constant,
2421 : &opline->op2.u.constant TSRMLS_CC);
2422 :
2423 :
2424 4 : ZEND_VM_NEXT_OPCODE();
2425 : }
2426 :
2427 : static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2428 20 : {
2429 20 : zend_op *opline = EX(opline);
2430 :
2431 :
2432 20 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
2433 : &opline->op1.u.constant,
2434 : &opline->op2.u.constant TSRMLS_CC);
2435 :
2436 :
2437 20 : ZEND_VM_NEXT_OPCODE();
2438 : }
2439 :
2440 : static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2441 0 : {
2442 0 : zend_op *opline = EX(opline);
2443 :
2444 :
2445 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
2446 : &opline->op1.u.constant,
2447 : &opline->op2.u.constant TSRMLS_CC);
2448 :
2449 :
2450 0 : ZEND_VM_NEXT_OPCODE();
2451 : }
2452 :
2453 : static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2454 20177 : {
2455 20177 : zend_op *opline = EX(opline);
2456 :
2457 :
2458 20177 : concat_function(&EX_T(opline->result.u.var).tmp_var,
2459 : &opline->op1.u.constant,
2460 : &opline->op2.u.constant TSRMLS_CC);
2461 :
2462 :
2463 20177 : ZEND_VM_NEXT_OPCODE();
2464 : }
2465 :
2466 : static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2467 0 : {
2468 0 : zend_op *opline = EX(opline);
2469 :
2470 :
2471 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
2472 : &opline->op1.u.constant,
2473 : &opline->op2.u.constant TSRMLS_CC);
2474 :
2475 :
2476 0 : ZEND_VM_NEXT_OPCODE();
2477 : }
2478 :
2479 : static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2480 0 : {
2481 0 : zend_op *opline = EX(opline);
2482 :
2483 0 : zval *result = &EX_T(opline->result.u.var).tmp_var;
2484 :
2485 0 : is_identical_function(result,
2486 : &opline->op1.u.constant,
2487 : &opline->op2.u.constant TSRMLS_CC);
2488 0 : Z_LVAL_P(result) = !Z_LVAL_P(result);
2489 :
2490 :
2491 0 : ZEND_VM_NEXT_OPCODE();
2492 : }
2493 :
2494 : static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2495 74 : {
2496 74 : zend_op *opline = EX(opline);
2497 :
2498 74 : zval *result = &EX_T(opline->result.u.var).tmp_var;
2499 :
2500 74 : compare_function(result,
2501 : &opline->op1.u.constant,
2502 : &opline->op2.u.constant TSRMLS_CC);
2503 74 : ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
2504 :
2505 :
2506 74 : ZEND_VM_NEXT_OPCODE();
2507 : }
2508 :
2509 : static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2510 294 : {
2511 294 : zend_op *opline = EX(opline);
2512 :
2513 294 : zval *result = &EX_T(opline->result.u.var).tmp_var;
2514 :
2515 294 : compare_function(result,
2516 : &opline->op1.u.constant,
2517 : &opline->op2.u.constant TSRMLS_CC);
2518 294 : ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
2519 :
2520 :
2521 294 : ZEND_VM_NEXT_OPCODE();
2522 : }
2523 :
2524 : static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2525 22 : {
2526 22 : zend_op *opline = EX(opline);
2527 :
2528 22 : zval *result = &EX_T(opline->result.u.var).tmp_var;
2529 :
2530 22 : compare_function(result,
2531 : &opline->op1.u.constant,
2532 : &opline->op2.u.constant TSRMLS_CC);
2533 22 : ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
2534 :
2535 :
2536 22 : ZEND_VM_NEXT_OPCODE();
2537 : }
2538 :
2539 : static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2540 0 : {
2541 0 : zend_op *opline = EX(opline);
2542 :
2543 0 : zval *result = &EX_T(opline->result.u.var).tmp_var;
2544 :
2545 0 : compare_function(result,
2546 : &opline->op1.u.constant,
2547 : &opline->op2.u.constant TSRMLS_CC);
2548 0 : ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
2549 :
2550 :
2551 0 : ZEND_VM_NEXT_OPCODE();
2552 : }
2553 :
2554 : static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2555 593 : {
2556 593 : zend_op *opline = EX(opline);
2557 :
2558 :
2559 593 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
2560 : &opline->op1.u.constant,
2561 : &opline->op2.u.constant TSRMLS_CC);
2562 :
2563 :
2564 593 : ZEND_VM_NEXT_OPCODE();
2565 : }
2566 :
2567 : static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2568 0 : {
2569 0 : zend_op *opline = EX(opline);
2570 :
2571 :
2572 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
2573 : &opline->op1.u.constant,
2574 : &opline->op2.u.constant TSRMLS_CC);
2575 :
2576 :
2577 0 : ZEND_VM_NEXT_OPCODE();
2578 : }
2579 :
2580 : static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2581 9 : {
2582 9 : zend_op *opline = EX(opline);
2583 :
2584 :
2585 9 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
2586 : &opline->op1.u.constant,
2587 : &opline->op2.u.constant TSRMLS_CC);
2588 :
2589 :
2590 9 : ZEND_VM_NEXT_OPCODE();
2591 : }
2592 :
2593 : static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2594 0 : {
2595 0 : zend_op *opline = EX(opline);
2596 :
2597 :
2598 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
2599 : &opline->op1.u.constant,
2600 : &opline->op2.u.constant TSRMLS_CC);
2601 :
2602 :
2603 0 : ZEND_VM_NEXT_OPCODE();
2604 : }
2605 :
2606 : static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2607 6 : {
2608 6 : zend_op *opline = EX(opline);
2609 :
2610 6 : zval *container = &opline->op1.u.constant;
2611 :
2612 6 : if (Z_TYPE_P(container) != IS_ARRAY) {
2613 6 : if (!RETURN_VALUE_UNUSED(&opline->result)) {
2614 6 : AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
2615 6 : PZVAL_LOCK(EG(uninitialized_zval_ptr));
2616 : }
2617 : } else {
2618 :
2619 0 : zval *dim = &opline->op2.u.constant;
2620 :
2621 0 : AI_SET_PTR(EX_T(opline->result.u.var).var, *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, BP_VAR_R TSRMLS_CC));
2622 0 : SELECTIVE_PZVAL_LOCK(EX_T(opline->result.u.var).var.ptr, &opline->result);
2623 :
2624 : }
2625 6 : ZEND_VM_NEXT_OPCODE();
2626 : }
2627 :
2628 : static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2629 4038 : {
2630 4038 : zend_op *opline = EX(opline);
2631 : zval *function_name;
2632 : zend_class_entry *ce;
2633 :
2634 4038 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
2635 :
2636 : if (IS_CONST == IS_CONST) {
2637 : /* no function found. try a static method in class */
2638 4038 : ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
2639 4038 : if (!ce) {
2640 0 : zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
2641 : }
2642 4038 : EX(called_scope) = ce;
2643 : } else {
2644 : ce = EX_T(opline->op1.u.var).class_entry;
2645 :
2646 : if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
2647 : EX(called_scope) = EG(called_scope);
2648 : } else {
2649 : EX(called_scope) = ce;
2650 : }
2651 : }
2652 : if(IS_CONST != IS_UNUSED) {
2653 4038 : char *function_name_strval = NULL;
2654 4038 : int function_name_strlen = 0;
2655 :
2656 :
2657 : if (IS_CONST == IS_CONST) {
2658 4038 : function_name_strval = Z_STRVAL(opline->op2.u.constant);
2659 4038 : function_name_strlen = Z_STRLEN(opline->op2.u.constant);
2660 : } else {
2661 : function_name = &opline->op2.u.constant;
2662 :
2663 : if (Z_TYPE_P(function_name) != IS_STRING) {
2664 : zend_error_noreturn(E_ERROR, "Function name must be a string");
2665 : } else {
2666 : function_name_strval = Z_STRVAL_P(function_name);
2667 : function_name_strlen = Z_STRLEN_P(function_name);
2668 : }
2669 : }
2670 :
2671 4038 : if (function_name_strval) {
2672 4038 : if (ce->get_static_method) {
2673 0 : EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
2674 : } else {
2675 4038 : EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
2676 : }
2677 4031 : if (!EX(fbc)) {
2678 4 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
2679 : }
2680 : }
2681 :
2682 : if (IS_CONST != IS_CONST) {
2683 :
2684 : }
2685 : } else {
2686 : if(!ce->constructor) {
2687 : zend_error_noreturn(E_ERROR, "Cannot call constructor");
2688 : }
2689 : if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
2690 : zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
2691 : }
2692 : EX(fbc) = ce->constructor;
2693 : }
2694 :
2695 4027 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
2696 3946 : EX(object) = NULL;
2697 : } else {
2698 81 : if (EG(This) &&
2699 : Z_OBJ_HT_P(EG(This))->get_class_entry &&
2700 : !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
2701 : /* We are calling method of the other (incompatible) class,
2702 : but passing $this. This is done for compatibility with php-4. */
2703 : int severity;
2704 : char *verb;
2705 1 : if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
2706 0 : severity = E_STRICT;
2707 0 : verb = "should not";
2708 : } else {
2709 : /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
2710 1 : severity = E_ERROR;
2711 1 : verb = "cannot";
2712 : }
2713 1 : zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
2714 :
2715 : }
2716 80 : if ((EX(object) = EG(This))) {
2717 57 : Z_ADDREF_P(EX(object));
2718 57 : EX(called_scope) = Z_OBJCE_P(EX(object));
2719 : }
2720 : }
2721 :
2722 4026 : ZEND_VM_NEXT_OPCODE();
2723 : }
2724 :
2725 : static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2726 12 : {
2727 12 : zend_op *opline = EX(opline);
2728 12 : int switch_expr_is_overloaded=0;
2729 :
2730 :
2731 : if (IS_CONST==IS_VAR) {
2732 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
2733 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
2734 : } else {
2735 : switch_expr_is_overloaded = 1;
2736 : Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
2737 : }
2738 : }
2739 12 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
2740 : &opline->op1.u.constant,
2741 : &opline->op2.u.constant TSRMLS_CC);
2742 :
2743 12 : if (switch_expr_is_overloaded) {
2744 : /* We only free op1 if this is a string offset,
2745 : * Since if it is a TMP_VAR, it'll be reused by
2746 : * other CASE opcodes (whereas string offsets
2747 : * are allocated at each get_zval_ptr())
2748 : */
2749 :
2750 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
2751 0 : EX_T(opline->op1.u.var).var.ptr = NULL;
2752 : }
2753 12 : ZEND_VM_NEXT_OPCODE();
2754 : }
2755 :
2756 : static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2757 9219 : {
2758 9219 : zend_op *opline = EX(opline);
2759 :
2760 : if (IS_CONST == IS_UNUSED) {
2761 : /* namespaced constant */
2762 : if (!zend_get_constant_ex(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), &EX_T(opline->result.u.var).tmp_var, NULL, opline->extended_value TSRMLS_CC)) {
2763 : if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
2764 : char *actual = (char *)zend_memrchr(Z_STRVAL(opline->op2.u.constant), '\\', Z_STRLEN(opline->op2.u.constant));
2765 : if(!actual) {
2766 : actual = Z_STRVAL(opline->op2.u.constant);
2767 : } else {
2768 : actual++;
2769 : }
2770 : /* non-qualified constant - allow text substitution */
2771 : zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
2772 : ZVAL_STRINGL(&EX_T(opline->result.u.var).tmp_var, actual, Z_STRLEN(opline->op2.u.constant)-(actual - Z_STRVAL(opline->op2.u.constant)), 1);
2773 : } else {
2774 : zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
2775 : Z_STRVAL(opline->op2.u.constant), Z_STRVAL(opline->op2.u.constant));
2776 : }
2777 : }
2778 : ZEND_VM_NEXT_OPCODE();
2779 : } else {
2780 : /* class constant */
2781 : zend_class_entry *ce;
2782 : zval **value;
2783 :
2784 : if (IS_CONST == IS_CONST) {
2785 :
2786 9219 : ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
2787 9218 : if (!ce) {
2788 0 : zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL(opline->op2.u.constant));
2789 : }
2790 : } else {
2791 : ce = EX_T(opline->op1.u.var).class_entry;
2792 : }
2793 :
2794 9218 : if (zend_hash_find(&ce->constants_table, Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void **) &value) == SUCCESS) {
2795 9216 : if (Z_TYPE_PP(value) == IS_CONSTANT_ARRAY ||
2796 : (Z_TYPE_PP(value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
2797 25 : zend_class_entry *old_scope = EG(scope);
2798 :
2799 25 : EG(scope) = ce;
2800 25 : zval_update_constant(value, (void *) 1 TSRMLS_CC);
2801 23 : EG(scope) = old_scope;
2802 : }
2803 9214 : EX_T(opline->result.u.var).tmp_var = **value;
2804 9214 : zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
2805 : } else {
2806 2 : zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL(opline->op2.u.constant));
2807 : }
2808 :
2809 9214 : ZEND_VM_NEXT_OPCODE();
2810 : }
2811 : }
2812 :
2813 : static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2814 66602 : {
2815 66602 : zend_op *opline = EX(opline);
2816 :
2817 66602 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
2818 : zval *expr_ptr;
2819 66602 : zval *offset=&opline->op2.u.constant;
2820 :
2821 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
2822 : zval **expr_ptr_ptr = NULL;
2823 :
2824 : if (opline->extended_value) {
2825 : expr_ptr_ptr=NULL;
2826 : expr_ptr = *expr_ptr_ptr;
2827 : } else {
2828 : expr_ptr=&opline->op1.u.constant;
2829 : }
2830 : #else
2831 66602 : expr_ptr=&opline->op1.u.constant;
2832 : #endif
2833 :
2834 : if (0) { /* temporary variable */
2835 : zval *new_expr;
2836 :
2837 : ALLOC_ZVAL(new_expr);
2838 : INIT_PZVAL_COPY(new_expr, expr_ptr);
2839 : expr_ptr = new_expr;
2840 : } else {
2841 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
2842 : if (opline->extended_value) {
2843 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
2844 : expr_ptr = *expr_ptr_ptr;
2845 : Z_ADDREF_P(expr_ptr);
2846 : } else
2847 : #endif
2848 : if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
2849 : zval *new_expr;
2850 :
2851 66602 : ALLOC_ZVAL(new_expr);
2852 66602 : INIT_PZVAL_COPY(new_expr, expr_ptr);
2853 66602 : expr_ptr = new_expr;
2854 66602 : zendi_zval_copy_ctor(*expr_ptr);
2855 : } else {
2856 : Z_ADDREF_P(expr_ptr);
2857 : }
2858 : }
2859 66602 : if (offset) {
2860 66602 : switch (Z_TYPE_P(offset)) {
2861 : case IS_DOUBLE:
2862 278 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
2863 278 : break;
2864 : case IS_LONG:
2865 : case IS_BOOL:
2866 2432 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
2867 2432 : break;
2868 : case IS_STRING:
2869 63769 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
2870 63769 : break;
2871 : case IS_NULL:
2872 123 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
2873 123 : break;
2874 : default:
2875 0 : zend_error(E_WARNING, "Illegal offset type");
2876 0 : zval_ptr_dtor(&expr_ptr);
2877 : /* do nothing */
2878 : break;
2879 : }
2880 :
2881 : } else {
2882 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
2883 : }
2884 66602 : if (opline->extended_value) {
2885 :
2886 : } else {
2887 :
2888 : }
2889 66602 : ZEND_VM_NEXT_OPCODE();
2890 : }
2891 :
2892 : static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2893 34311 : {
2894 34311 : zend_op *opline = EX(opline);
2895 :
2896 34311 : array_init(&EX_T(opline->result.u.var).tmp_var);
2897 : if (IS_CONST == IS_UNUSED) {
2898 : ZEND_VM_NEXT_OPCODE();
2899 : #if 0 || IS_CONST != IS_UNUSED
2900 : } else {
2901 34311 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2902 : #endif
2903 : }
2904 : }
2905 :
2906 : static int ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2907 32 : {
2908 32 : zend_op *opline = EX(opline);
2909 :
2910 32 : zval *name = &opline->op1.u.constant;
2911 32 : zval *val = &opline->op2.u.constant;
2912 : zend_constant c;
2913 :
2914 34 : if ((Z_TYPE_P(val) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT || Z_TYPE_P(val) == IS_CONSTANT_ARRAY) {
2915 2 : zval tmp = *val;
2916 2 : zval *tmp_ptr = &tmp;
2917 :
2918 2 : if (Z_TYPE_P(val) == IS_CONSTANT_ARRAY) {
2919 0 : zval_copy_ctor(&tmp);
2920 : }
2921 2 : INIT_PZVAL(&tmp);
2922 2 : zval_update_constant(&tmp_ptr, NULL TSRMLS_CC);
2923 2 : c.value = *tmp_ptr;
2924 : } else {
2925 30 : c.value = *val;
2926 30 : zval_copy_ctor(&c.value);
2927 : }
2928 32 : c.flags = CONST_CS; /* non persistent, case sensetive */
2929 32 : c.name = zend_strndup(Z_STRVAL_P(name), Z_STRLEN_P(name));
2930 32 : c.name_len = Z_STRLEN_P(name)+1;
2931 32 : c.module_number = PHP_USER_CONSTANT;
2932 :
2933 32 : if (zend_register_constant(&c TSRMLS_CC) == FAILURE) {
2934 : }
2935 :
2936 :
2937 32 : ZEND_VM_NEXT_OPCODE();
2938 : }
2939 :
2940 : static int ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2941 99 : {
2942 99 : zend_op *opline = EX(opline);
2943 : zend_function *op_array;
2944 :
2945 99 : if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), Z_LVAL(opline->op2.u.constant), (void *) &op_array) == FAILURE ||
2946 : op_array->type != ZEND_USER_FUNCTION) {
2947 0 : zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
2948 : }
2949 :
2950 99 : zend_create_closure(&EX_T(opline->result.u.var).tmp_var, op_array TSRMLS_CC);
2951 :
2952 99 : ZEND_VM_NEXT_OPCODE();
2953 : }
2954 :
2955 : static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2956 61699 : {
2957 61699 : zend_op *opline = EX(opline);
2958 : zend_free_op free_op2;
2959 :
2960 61699 : add_function(&EX_T(opline->result.u.var).tmp_var,
2961 : &opline->op1.u.constant,
2962 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2963 :
2964 61699 : zval_dtor(free_op2.var);
2965 61699 : ZEND_VM_NEXT_OPCODE();
2966 : }
2967 :
2968 : static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2969 39 : {
2970 39 : zend_op *opline = EX(opline);
2971 : zend_free_op free_op2;
2972 :
2973 39 : sub_function(&EX_T(opline->result.u.var).tmp_var,
2974 : &opline->op1.u.constant,
2975 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2976 :
2977 39 : zval_dtor(free_op2.var);
2978 39 : ZEND_VM_NEXT_OPCODE();
2979 : }
2980 :
2981 : static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2982 3 : {
2983 3 : zend_op *opline = EX(opline);
2984 : zend_free_op free_op2;
2985 :
2986 3 : mul_function(&EX_T(opline->result.u.var).tmp_var,
2987 : &opline->op1.u.constant,
2988 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
2989 :
2990 3 : zval_dtor(free_op2.var);
2991 3 : ZEND_VM_NEXT_OPCODE();
2992 : }
2993 :
2994 : static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2995 0 : {
2996 0 : zend_op *opline = EX(opline);
2997 : zend_free_op free_op2;
2998 :
2999 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
3000 : &opline->op1.u.constant,
3001 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3002 :
3003 0 : zval_dtor(free_op2.var);
3004 0 : ZEND_VM_NEXT_OPCODE();
3005 : }
3006 :
3007 : static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3008 0 : {
3009 0 : zend_op *opline = EX(opline);
3010 : zend_free_op free_op2;
3011 :
3012 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
3013 : &opline->op1.u.constant,
3014 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3015 :
3016 0 : zval_dtor(free_op2.var);
3017 0 : ZEND_VM_NEXT_OPCODE();
3018 : }
3019 :
3020 : static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3021 0 : {
3022 0 : zend_op *opline = EX(opline);
3023 : zend_free_op free_op2;
3024 :
3025 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
3026 : &opline->op1.u.constant,
3027 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3028 :
3029 0 : zval_dtor(free_op2.var);
3030 0 : ZEND_VM_NEXT_OPCODE();
3031 : }
3032 :
3033 : static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3034 0 : {
3035 0 : zend_op *opline = EX(opline);
3036 : zend_free_op free_op2;
3037 :
3038 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
3039 : &opline->op1.u.constant,
3040 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3041 :
3042 0 : zval_dtor(free_op2.var);
3043 0 : ZEND_VM_NEXT_OPCODE();
3044 : }
3045 :
3046 : static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3047 1743 : {
3048 1743 : zend_op *opline = EX(opline);
3049 : zend_free_op free_op2;
3050 :
3051 1743 : concat_function(&EX_T(opline->result.u.var).tmp_var,
3052 : &opline->op1.u.constant,
3053 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3054 :
3055 1743 : zval_dtor(free_op2.var);
3056 1743 : ZEND_VM_NEXT_OPCODE();
3057 : }
3058 :
3059 : static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3060 0 : {
3061 0 : zend_op *opline = EX(opline);
3062 : zend_free_op free_op2;
3063 :
3064 0 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
3065 : &opline->op1.u.constant,
3066 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3067 :
3068 0 : zval_dtor(free_op2.var);
3069 0 : ZEND_VM_NEXT_OPCODE();
3070 : }
3071 :
3072 : static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3073 0 : {
3074 0 : zend_op *opline = EX(opline);
3075 : zend_free_op free_op2;
3076 0 : zval *result = &EX_T(opline->result.u.var).tmp_var;
3077 :
3078 0 : is_identical_function(result,
3079 : &opline->op1.u.constant,
3080 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3081 0 : Z_LVAL_P(result) = !Z_LVAL_P(result);
3082 :
3083 0 : zval_dtor(free_op2.var);
3084 0 : ZEND_VM_NEXT_OPCODE();
3085 : }
3086 :
3087 : static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3088 12 : {
3089 12 : zend_op *opline = EX(opline);
3090 : zend_free_op free_op2;
3091 12 : zval *result = &EX_T(opline->result.u.var).tmp_var;
3092 :
3093 12 : compare_function(result,
3094 : &opline->op1.u.constant,
3095 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3096 12 : ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
3097 :
3098 12 : zval_dtor(free_op2.var);
3099 12 : ZEND_VM_NEXT_OPCODE();
3100 : }
3101 :
3102 : static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3103 0 : {
3104 0 : zend_op *opline = EX(opline);
3105 : zend_free_op free_op2;
3106 0 : zval *result = &EX_T(opline->result.u.var).tmp_var;
3107 :
3108 0 : compare_function(result,
3109 : &opline->op1.u.constant,
3110 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3111 0 : ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
3112 :
3113 0 : zval_dtor(free_op2.var);
3114 0 : ZEND_VM_NEXT_OPCODE();
3115 : }
3116 :
3117 : static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3118 236012 : {
3119 236012 : zend_op *opline = EX(opline);
3120 : zend_free_op free_op2;
3121 236012 : zval *result = &EX_T(opline->result.u.var).tmp_var;
3122 :
3123 236012 : compare_function(result,
3124 : &opline->op1.u.constant,
3125 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3126 236012 : ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
3127 :
3128 236012 : zval_dtor(free_op2.var);
3129 236012 : ZEND_VM_NEXT_OPCODE();
3130 : }
3131 :
3132 : static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3133 18301 : {
3134 18301 : zend_op *opline = EX(opline);
3135 : zend_free_op free_op2;
3136 18301 : zval *result = &EX_T(opline->result.u.var).tmp_var;
3137 :
3138 18301 : compare_function(result,
3139 : &opline->op1.u.constant,
3140 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3141 18301 : ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
3142 :
3143 18301 : zval_dtor(free_op2.var);
3144 18301 : ZEND_VM_NEXT_OPCODE();
3145 : }
3146 :
3147 : static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3148 6189 : {
3149 6189 : zend_op *opline = EX(opline);
3150 : zend_free_op free_op2;
3151 :
3152 6189 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
3153 : &opline->op1.u.constant,
3154 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3155 :
3156 6189 : zval_dtor(free_op2.var);
3157 6189 : ZEND_VM_NEXT_OPCODE();
3158 : }
3159 :
3160 : static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3161 77 : {
3162 77 : zend_op *opline = EX(opline);
3163 : zend_free_op free_op2;
3164 :
3165 77 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
3166 : &opline->op1.u.constant,
3167 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3168 :
3169 77 : zval_dtor(free_op2.var);
3170 77 : ZEND_VM_NEXT_OPCODE();
3171 : }
3172 :
3173 : static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3174 0 : {
3175 0 : zend_op *opline = EX(opline);
3176 : zend_free_op free_op2;
3177 :
3178 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
3179 : &opline->op1.u.constant,
3180 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3181 :
3182 0 : zval_dtor(free_op2.var);
3183 0 : ZEND_VM_NEXT_OPCODE();
3184 : }
3185 :
3186 : static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3187 0 : {
3188 0 : zend_op *opline = EX(opline);
3189 : zend_free_op free_op2;
3190 :
3191 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
3192 : &opline->op1.u.constant,
3193 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3194 :
3195 0 : zval_dtor(free_op2.var);
3196 0 : ZEND_VM_NEXT_OPCODE();
3197 : }
3198 :
3199 : static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3200 0 : {
3201 0 : zend_op *opline = EX(opline);
3202 : zval *function_name;
3203 : zend_class_entry *ce;
3204 :
3205 0 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
3206 :
3207 : if (IS_CONST == IS_CONST) {
3208 : /* no function found. try a static method in class */
3209 0 : ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
3210 0 : if (!ce) {
3211 0 : zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
3212 : }
3213 0 : EX(called_scope) = ce;
3214 : } else {
3215 : ce = EX_T(opline->op1.u.var).class_entry;
3216 :
3217 : if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
3218 : EX(called_scope) = EG(called_scope);
3219 : } else {
3220 : EX(called_scope) = ce;
3221 : }
3222 : }
3223 : if(IS_TMP_VAR != IS_UNUSED) {
3224 0 : char *function_name_strval = NULL;
3225 0 : int function_name_strlen = 0;
3226 : zend_free_op free_op2;
3227 :
3228 : if (IS_TMP_VAR == IS_CONST) {
3229 : function_name_strval = Z_STRVAL(opline->op2.u.constant);
3230 : function_name_strlen = Z_STRLEN(opline->op2.u.constant);
3231 : } else {
3232 0 : function_name = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
3233 :
3234 0 : if (Z_TYPE_P(function_name) != IS_STRING) {
3235 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
3236 : } else {
3237 0 : function_name_strval = Z_STRVAL_P(function_name);
3238 0 : function_name_strlen = Z_STRLEN_P(function_name);
3239 : }
3240 : }
3241 :
3242 0 : if (function_name_strval) {
3243 0 : if (ce->get_static_method) {
3244 0 : EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3245 : } else {
3246 0 : EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3247 : }
3248 0 : if (!EX(fbc)) {
3249 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
3250 : }
3251 : }
3252 :
3253 : if (IS_TMP_VAR != IS_CONST) {
3254 0 : zval_dtor(free_op2.var);
3255 : }
3256 : } else {
3257 : if(!ce->constructor) {
3258 : zend_error_noreturn(E_ERROR, "Cannot call constructor");
3259 : }
3260 : if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
3261 : zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
3262 : }
3263 : EX(fbc) = ce->constructor;
3264 : }
3265 :
3266 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
3267 0 : EX(object) = NULL;
3268 : } else {
3269 0 : if (EG(This) &&
3270 : Z_OBJ_HT_P(EG(This))->get_class_entry &&
3271 : !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
3272 : /* We are calling method of the other (incompatible) class,
3273 : but passing $this. This is done for compatibility with php-4. */
3274 : int severity;
3275 : char *verb;
3276 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3277 0 : severity = E_STRICT;
3278 0 : verb = "should not";
3279 : } else {
3280 : /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
3281 0 : severity = E_ERROR;
3282 0 : verb = "cannot";
3283 : }
3284 0 : zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
3285 :
3286 : }
3287 0 : if ((EX(object) = EG(This))) {
3288 0 : Z_ADDREF_P(EX(object));
3289 0 : EX(called_scope) = Z_OBJCE_P(EX(object));
3290 : }
3291 : }
3292 :
3293 0 : ZEND_VM_NEXT_OPCODE();
3294 : }
3295 :
3296 : static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3297 66 : {
3298 66 : zend_op *opline = EX(opline);
3299 66 : int switch_expr_is_overloaded=0;
3300 : zend_free_op free_op2;
3301 :
3302 : if (IS_CONST==IS_VAR) {
3303 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
3304 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
3305 : } else {
3306 : switch_expr_is_overloaded = 1;
3307 : Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
3308 : }
3309 : }
3310 66 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
3311 : &opline->op1.u.constant,
3312 : _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3313 :
3314 66 : zval_dtor(free_op2.var);
3315 66 : if (switch_expr_is_overloaded) {
3316 : /* We only free op1 if this is a string offset,
3317 : * Since if it is a TMP_VAR, it'll be reused by
3318 : * other CASE opcodes (whereas string offsets
3319 : * are allocated at each get_zval_ptr())
3320 : */
3321 :
3322 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
3323 0 : EX_T(opline->op1.u.var).var.ptr = NULL;
3324 : }
3325 66 : ZEND_VM_NEXT_OPCODE();
3326 : }
3327 :
3328 : static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3329 203 : {
3330 203 : zend_op *opline = EX(opline);
3331 : zend_free_op free_op2;
3332 203 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3333 : zval *expr_ptr;
3334 203 : zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
3335 :
3336 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3337 : zval **expr_ptr_ptr = NULL;
3338 :
3339 : if (opline->extended_value) {
3340 : expr_ptr_ptr=NULL;
3341 : expr_ptr = *expr_ptr_ptr;
3342 : } else {
3343 : expr_ptr=&opline->op1.u.constant;
3344 : }
3345 : #else
3346 203 : expr_ptr=&opline->op1.u.constant;
3347 : #endif
3348 :
3349 : if (0) { /* temporary variable */
3350 : zval *new_expr;
3351 :
3352 : ALLOC_ZVAL(new_expr);
3353 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3354 : expr_ptr = new_expr;
3355 : } else {
3356 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3357 : if (opline->extended_value) {
3358 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
3359 : expr_ptr = *expr_ptr_ptr;
3360 : Z_ADDREF_P(expr_ptr);
3361 : } else
3362 : #endif
3363 : if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
3364 : zval *new_expr;
3365 :
3366 203 : ALLOC_ZVAL(new_expr);
3367 203 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3368 203 : expr_ptr = new_expr;
3369 203 : zendi_zval_copy_ctor(*expr_ptr);
3370 : } else {
3371 : Z_ADDREF_P(expr_ptr);
3372 : }
3373 : }
3374 203 : if (offset) {
3375 203 : switch (Z_TYPE_P(offset)) {
3376 : case IS_DOUBLE:
3377 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
3378 0 : break;
3379 : case IS_LONG:
3380 : case IS_BOOL:
3381 131 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3382 131 : break;
3383 : case IS_STRING:
3384 71 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
3385 71 : break;
3386 : case IS_NULL:
3387 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
3388 0 : break;
3389 : default:
3390 1 : zend_error(E_WARNING, "Illegal offset type");
3391 1 : zval_ptr_dtor(&expr_ptr);
3392 : /* do nothing */
3393 : break;
3394 : }
3395 203 : zval_dtor(free_op2.var);
3396 : } else {
3397 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
3398 : }
3399 203 : if (opline->extended_value) {
3400 :
3401 : } else {
3402 :
3403 : }
3404 203 : ZEND_VM_NEXT_OPCODE();
3405 : }
3406 :
3407 : static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3408 101 : {
3409 101 : zend_op *opline = EX(opline);
3410 :
3411 101 : array_init(&EX_T(opline->result.u.var).tmp_var);
3412 : if (IS_CONST == IS_UNUSED) {
3413 : ZEND_VM_NEXT_OPCODE();
3414 : #if 0 || IS_CONST != IS_UNUSED
3415 : } else {
3416 101 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3417 : #endif
3418 : }
3419 : }
3420 :
3421 : static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3422 1 : {
3423 1 : zend_op *opline = EX(opline);
3424 : zend_free_op free_op2;
3425 :
3426 1 : add_function(&EX_T(opline->result.u.var).tmp_var,
3427 : &opline->op1.u.constant,
3428 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3429 :
3430 1 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3431 1 : ZEND_VM_NEXT_OPCODE();
3432 : }
3433 :
3434 : static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3435 2180 : {
3436 2180 : zend_op *opline = EX(opline);
3437 : zend_free_op free_op2;
3438 :
3439 2180 : sub_function(&EX_T(opline->result.u.var).tmp_var,
3440 : &opline->op1.u.constant,
3441 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3442 :
3443 2180 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3444 2180 : ZEND_VM_NEXT_OPCODE();
3445 : }
3446 :
3447 : static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3448 15 : {
3449 15 : zend_op *opline = EX(opline);
3450 : zend_free_op free_op2;
3451 :
3452 15 : mul_function(&EX_T(opline->result.u.var).tmp_var,
3453 : &opline->op1.u.constant,
3454 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3455 :
3456 15 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3457 15 : ZEND_VM_NEXT_OPCODE();
3458 : }
3459 :
3460 : static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3461 0 : {
3462 0 : zend_op *opline = EX(opline);
3463 : zend_free_op free_op2;
3464 :
3465 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
3466 : &opline->op1.u.constant,
3467 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3468 :
3469 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3470 0 : ZEND_VM_NEXT_OPCODE();
3471 : }
3472 :
3473 : static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3474 0 : {
3475 0 : zend_op *opline = EX(opline);
3476 : zend_free_op free_op2;
3477 :
3478 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
3479 : &opline->op1.u.constant,
3480 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3481 :
3482 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3483 0 : ZEND_VM_NEXT_OPCODE();
3484 : }
3485 :
3486 : static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3487 0 : {
3488 0 : zend_op *opline = EX(opline);
3489 : zend_free_op free_op2;
3490 :
3491 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
3492 : &opline->op1.u.constant,
3493 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3494 :
3495 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3496 0 : ZEND_VM_NEXT_OPCODE();
3497 : }
3498 :
3499 : static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3500 0 : {
3501 0 : zend_op *opline = EX(opline);
3502 : zend_free_op free_op2;
3503 :
3504 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
3505 : &opline->op1.u.constant,
3506 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3507 :
3508 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3509 0 : ZEND_VM_NEXT_OPCODE();
3510 : }
3511 :
3512 : static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3513 145684 : {
3514 145684 : zend_op *opline = EX(opline);
3515 : zend_free_op free_op2;
3516 :
3517 145684 : concat_function(&EX_T(opline->result.u.var).tmp_var,
3518 : &opline->op1.u.constant,
3519 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3520 :
3521 145684 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3522 145684 : ZEND_VM_NEXT_OPCODE();
3523 : }
3524 :
3525 : static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3526 112 : {
3527 112 : zend_op *opline = EX(opline);
3528 : zend_free_op free_op2;
3529 :
3530 112 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
3531 : &opline->op1.u.constant,
3532 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3533 :
3534 112 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3535 112 : ZEND_VM_NEXT_OPCODE();
3536 : }
3537 :
3538 : static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3539 25874 : {
3540 25874 : zend_op *opline = EX(opline);
3541 : zend_free_op free_op2;
3542 25874 : zval *result = &EX_T(opline->result.u.var).tmp_var;
3543 :
3544 25874 : is_identical_function(result,
3545 : &opline->op1.u.constant,
3546 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3547 25874 : Z_LVAL_P(result) = !Z_LVAL_P(result);
3548 :
3549 25874 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3550 25874 : ZEND_VM_NEXT_OPCODE();
3551 : }
3552 :
3553 : static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3554 2307 : {
3555 2307 : zend_op *opline = EX(opline);
3556 : zend_free_op free_op2;
3557 2307 : zval *result = &EX_T(opline->result.u.var).tmp_var;
3558 :
3559 2307 : compare_function(result,
3560 : &opline->op1.u.constant,
3561 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3562 2307 : ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
3563 :
3564 2307 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3565 2307 : ZEND_VM_NEXT_OPCODE();
3566 : }
3567 :
3568 : static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3569 98 : {
3570 98 : zend_op *opline = EX(opline);
3571 : zend_free_op free_op2;
3572 98 : zval *result = &EX_T(opline->result.u.var).tmp_var;
3573 :
3574 98 : compare_function(result,
3575 : &opline->op1.u.constant,
3576 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3577 98 : ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
3578 :
3579 98 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3580 98 : ZEND_VM_NEXT_OPCODE();
3581 : }
3582 :
3583 : static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3584 151702 : {
3585 151702 : zend_op *opline = EX(opline);
3586 : zend_free_op free_op2;
3587 151702 : zval *result = &EX_T(opline->result.u.var).tmp_var;
3588 :
3589 151702 : compare_function(result,
3590 : &opline->op1.u.constant,
3591 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3592 151702 : ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
3593 :
3594 151702 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3595 151702 : ZEND_VM_NEXT_OPCODE();
3596 : }
3597 :
3598 : static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3599 27 : {
3600 27 : zend_op *opline = EX(opline);
3601 : zend_free_op free_op2;
3602 27 : zval *result = &EX_T(opline->result.u.var).tmp_var;
3603 :
3604 27 : compare_function(result,
3605 : &opline->op1.u.constant,
3606 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3607 27 : ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
3608 :
3609 27 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3610 27 : ZEND_VM_NEXT_OPCODE();
3611 : }
3612 :
3613 : static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3614 0 : {
3615 0 : zend_op *opline = EX(opline);
3616 : zend_free_op free_op2;
3617 :
3618 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
3619 : &opline->op1.u.constant,
3620 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3621 :
3622 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3623 0 : ZEND_VM_NEXT_OPCODE();
3624 : }
3625 :
3626 : static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3627 1 : {
3628 1 : zend_op *opline = EX(opline);
3629 : zend_free_op free_op2;
3630 :
3631 1 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
3632 : &opline->op1.u.constant,
3633 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3634 :
3635 1 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3636 1 : ZEND_VM_NEXT_OPCODE();
3637 : }
3638 :
3639 : static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3640 0 : {
3641 0 : zend_op *opline = EX(opline);
3642 : zend_free_op free_op2;
3643 :
3644 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
3645 : &opline->op1.u.constant,
3646 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3647 :
3648 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3649 0 : ZEND_VM_NEXT_OPCODE();
3650 : }
3651 :
3652 : static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3653 0 : {
3654 0 : zend_op *opline = EX(opline);
3655 : zend_free_op free_op2;
3656 :
3657 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
3658 : &opline->op1.u.constant,
3659 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3660 :
3661 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3662 0 : ZEND_VM_NEXT_OPCODE();
3663 : }
3664 :
3665 : static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3666 2 : {
3667 2 : zend_op *opline = EX(opline);
3668 : zval *function_name;
3669 : zend_class_entry *ce;
3670 :
3671 2 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
3672 :
3673 : if (IS_CONST == IS_CONST) {
3674 : /* no function found. try a static method in class */
3675 2 : ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
3676 2 : if (!ce) {
3677 0 : zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
3678 : }
3679 2 : EX(called_scope) = ce;
3680 : } else {
3681 : ce = EX_T(opline->op1.u.var).class_entry;
3682 :
3683 : if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
3684 : EX(called_scope) = EG(called_scope);
3685 : } else {
3686 : EX(called_scope) = ce;
3687 : }
3688 : }
3689 : if(IS_VAR != IS_UNUSED) {
3690 2 : char *function_name_strval = NULL;
3691 2 : int function_name_strlen = 0;
3692 : zend_free_op free_op2;
3693 :
3694 : if (IS_VAR == IS_CONST) {
3695 : function_name_strval = Z_STRVAL(opline->op2.u.constant);
3696 : function_name_strlen = Z_STRLEN(opline->op2.u.constant);
3697 : } else {
3698 2 : function_name = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
3699 :
3700 2 : if (Z_TYPE_P(function_name) != IS_STRING) {
3701 0 : zend_error_noreturn(E_ERROR, "Function name must be a string");
3702 : } else {
3703 2 : function_name_strval = Z_STRVAL_P(function_name);
3704 2 : function_name_strlen = Z_STRLEN_P(function_name);
3705 : }
3706 : }
3707 :
3708 2 : if (function_name_strval) {
3709 2 : if (ce->get_static_method) {
3710 0 : EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3711 : } else {
3712 2 : EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3713 : }
3714 2 : if (!EX(fbc)) {
3715 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
3716 : }
3717 : }
3718 :
3719 : if (IS_VAR != IS_CONST) {
3720 2 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3721 : }
3722 : } else {
3723 : if(!ce->constructor) {
3724 : zend_error_noreturn(E_ERROR, "Cannot call constructor");
3725 : }
3726 : if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
3727 : zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
3728 : }
3729 : EX(fbc) = ce->constructor;
3730 : }
3731 :
3732 2 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
3733 1 : EX(object) = NULL;
3734 : } else {
3735 1 : if (EG(This) &&
3736 : Z_OBJ_HT_P(EG(This))->get_class_entry &&
3737 : !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
3738 : /* We are calling method of the other (incompatible) class,
3739 : but passing $this. This is done for compatibility with php-4. */
3740 : int severity;
3741 : char *verb;
3742 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3743 0 : severity = E_STRICT;
3744 0 : verb = "should not";
3745 : } else {
3746 : /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
3747 0 : severity = E_ERROR;
3748 0 : verb = "cannot";
3749 : }
3750 0 : zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
3751 :
3752 : }
3753 1 : if ((EX(object) = EG(This))) {
3754 0 : Z_ADDREF_P(EX(object));
3755 0 : EX(called_scope) = Z_OBJCE_P(EX(object));
3756 : }
3757 : }
3758 :
3759 2 : ZEND_VM_NEXT_OPCODE();
3760 : }
3761 :
3762 : static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3763 0 : {
3764 0 : zend_op *opline = EX(opline);
3765 0 : int switch_expr_is_overloaded=0;
3766 : zend_free_op free_op2;
3767 :
3768 : if (IS_CONST==IS_VAR) {
3769 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
3770 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
3771 : } else {
3772 : switch_expr_is_overloaded = 1;
3773 : Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
3774 : }
3775 : }
3776 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
3777 : &opline->op1.u.constant,
3778 : _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) TSRMLS_CC);
3779 :
3780 0 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3781 0 : if (switch_expr_is_overloaded) {
3782 : /* We only free op1 if this is a string offset,
3783 : * Since if it is a TMP_VAR, it'll be reused by
3784 : * other CASE opcodes (whereas string offsets
3785 : * are allocated at each get_zval_ptr())
3786 : */
3787 :
3788 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
3789 0 : EX_T(opline->op1.u.var).var.ptr = NULL;
3790 : }
3791 0 : ZEND_VM_NEXT_OPCODE();
3792 : }
3793 :
3794 : static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3795 56 : {
3796 56 : zend_op *opline = EX(opline);
3797 : zend_free_op free_op2;
3798 56 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3799 : zval *expr_ptr;
3800 56 : zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
3801 :
3802 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3803 : zval **expr_ptr_ptr = NULL;
3804 :
3805 : if (opline->extended_value) {
3806 : expr_ptr_ptr=NULL;
3807 : expr_ptr = *expr_ptr_ptr;
3808 : } else {
3809 : expr_ptr=&opline->op1.u.constant;
3810 : }
3811 : #else
3812 56 : expr_ptr=&opline->op1.u.constant;
3813 : #endif
3814 :
3815 : if (0) { /* temporary variable */
3816 : zval *new_expr;
3817 :
3818 : ALLOC_ZVAL(new_expr);
3819 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3820 : expr_ptr = new_expr;
3821 : } else {
3822 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3823 : if (opline->extended_value) {
3824 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
3825 : expr_ptr = *expr_ptr_ptr;
3826 : Z_ADDREF_P(expr_ptr);
3827 : } else
3828 : #endif
3829 : if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
3830 : zval *new_expr;
3831 :
3832 56 : ALLOC_ZVAL(new_expr);
3833 56 : INIT_PZVAL_COPY(new_expr, expr_ptr);
3834 56 : expr_ptr = new_expr;
3835 56 : zendi_zval_copy_ctor(*expr_ptr);
3836 : } else {
3837 : Z_ADDREF_P(expr_ptr);
3838 : }
3839 : }
3840 56 : if (offset) {
3841 56 : switch (Z_TYPE_P(offset)) {
3842 : case IS_DOUBLE:
3843 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
3844 0 : break;
3845 : case IS_LONG:
3846 : case IS_BOOL:
3847 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
3848 0 : break;
3849 : case IS_STRING:
3850 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
3851 0 : break;
3852 : case IS_NULL:
3853 45 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
3854 45 : break;
3855 : default:
3856 11 : zend_error(E_WARNING, "Illegal offset type");
3857 11 : zval_ptr_dtor(&expr_ptr);
3858 : /* do nothing */
3859 : break;
3860 : }
3861 56 : if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
3862 : } else {
3863 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
3864 : }
3865 56 : if (opline->extended_value) {
3866 :
3867 : } else {
3868 :
3869 : }
3870 56 : ZEND_VM_NEXT_OPCODE();
3871 : }
3872 :
3873 : static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3874 38 : {
3875 38 : zend_op *opline = EX(opline);
3876 :
3877 38 : array_init(&EX_T(opline->result.u.var).tmp_var);
3878 : if (IS_CONST == IS_UNUSED) {
3879 : ZEND_VM_NEXT_OPCODE();
3880 : #if 0 || IS_CONST != IS_UNUSED
3881 : } else {
3882 38 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3883 : #endif
3884 : }
3885 : }
3886 :
3887 : static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3888 1 : {
3889 1 : zend_op *opline = EX(opline);
3890 : zval *function_name;
3891 : zend_class_entry *ce;
3892 :
3893 1 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
3894 :
3895 : if (IS_CONST == IS_CONST) {
3896 : /* no function found. try a static method in class */
3897 1 : ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
3898 1 : if (!ce) {
3899 0 : zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
3900 : }
3901 1 : EX(called_scope) = ce;
3902 : } else {
3903 : ce = EX_T(opline->op1.u.var).class_entry;
3904 :
3905 : if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
3906 : EX(called_scope) = EG(called_scope);
3907 : } else {
3908 : EX(called_scope) = ce;
3909 : }
3910 : }
3911 : if(IS_UNUSED != IS_UNUSED) {
3912 : char *function_name_strval = NULL;
3913 : int function_name_strlen = 0;
3914 :
3915 :
3916 : if (IS_UNUSED == IS_CONST) {
3917 : function_name_strval = Z_STRVAL(opline->op2.u.constant);
3918 : function_name_strlen = Z_STRLEN(opline->op2.u.constant);
3919 : } else {
3920 : function_name = NULL;
3921 :
3922 : if (Z_TYPE_P(function_name) != IS_STRING) {
3923 : zend_error_noreturn(E_ERROR, "Function name must be a string");
3924 : } else {
3925 : function_name_strval = Z_STRVAL_P(function_name);
3926 : function_name_strlen = Z_STRLEN_P(function_name);
3927 : }
3928 : }
3929 :
3930 : if (function_name_strval) {
3931 : if (ce->get_static_method) {
3932 : EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3933 : } else {
3934 : EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3935 : }
3936 : if (!EX(fbc)) {
3937 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
3938 : }
3939 : }
3940 :
3941 : if (IS_UNUSED != IS_CONST) {
3942 :
3943 : }
3944 : } else {
3945 1 : if(!ce->constructor) {
3946 1 : zend_error_noreturn(E_ERROR, "Cannot call constructor");
3947 : }
3948 0 : if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
3949 0 : zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
3950 : }
3951 0 : EX(fbc) = ce->constructor;
3952 : }
3953 :
3954 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
3955 0 : EX(object) = NULL;
3956 : } else {
3957 0 : if (EG(This) &&
3958 : Z_OBJ_HT_P(EG(This))->get_class_entry &&
3959 : !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
3960 : /* We are calling method of the other (incompatible) class,
3961 : but passing $this. This is done for compatibility with php-4. */
3962 : int severity;
3963 : char *verb;
3964 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3965 0 : severity = E_STRICT;
3966 0 : verb = "should not";
3967 : } else {
3968 : /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
3969 0 : severity = E_ERROR;
3970 0 : verb = "cannot";
3971 : }
3972 0 : zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
3973 :
3974 : }
3975 0 : if ((EX(object) = EG(This))) {
3976 0 : Z_ADDREF_P(EX(object));
3977 0 : EX(called_scope) = Z_OBJCE_P(EX(object));
3978 : }
3979 : }
3980 :
3981 0 : ZEND_VM_NEXT_OPCODE();
3982 : }
3983 :
3984 : static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3985 325499 : {
3986 325499 : zend_op *opline = EX(opline);
3987 :
3988 325499 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
3989 : zval *expr_ptr;
3990 325499 : zval *offset=NULL;
3991 :
3992 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
3993 : zval **expr_ptr_ptr = NULL;
3994 :
3995 : if (opline->extended_value) {
3996 : expr_ptr_ptr=NULL;
3997 : expr_ptr = *expr_ptr_ptr;
3998 : } else {
3999 : expr_ptr=&opline->op1.u.constant;
4000 : }
4001 : #else
4002 325499 : expr_ptr=&opline->op1.u.constant;
4003 : #endif
4004 :
4005 : if (0) { /* temporary variable */
4006 : zval *new_expr;
4007 :
4008 : ALLOC_ZVAL(new_expr);
4009 : INIT_PZVAL_COPY(new_expr, expr_ptr);
4010 : expr_ptr = new_expr;
4011 : } else {
4012 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
4013 : if (opline->extended_value) {
4014 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
4015 : expr_ptr = *expr_ptr_ptr;
4016 : Z_ADDREF_P(expr_ptr);
4017 : } else
4018 : #endif
4019 : if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
4020 : zval *new_expr;
4021 :
4022 325499 : ALLOC_ZVAL(new_expr);
4023 325499 : INIT_PZVAL_COPY(new_expr, expr_ptr);
4024 325499 : expr_ptr = new_expr;
4025 325499 : zendi_zval_copy_ctor(*expr_ptr);
4026 : } else {
4027 : Z_ADDREF_P(expr_ptr);
4028 : }
4029 : }
4030 325499 : if (offset) {
4031 0 : switch (Z_TYPE_P(offset)) {
4032 : case IS_DOUBLE:
4033 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
4034 0 : break;
4035 : case IS_LONG:
4036 : case IS_BOOL:
4037 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
4038 0 : break;
4039 : case IS_STRING:
4040 0 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
4041 0 : break;
4042 : case IS_NULL:
4043 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
4044 0 : break;
4045 : default:
4046 0 : zend_error(E_WARNING, "Illegal offset type");
4047 0 : zval_ptr_dtor(&expr_ptr);
4048 : /* do nothing */
4049 : break;
4050 : }
4051 :
4052 : } else {
4053 325499 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
4054 : }
4055 325499 : if (opline->extended_value) {
4056 :
4057 : } else {
4058 :
4059 : }
4060 325499 : ZEND_VM_NEXT_OPCODE();
4061 : }
4062 :
4063 : static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4064 204501 : {
4065 204501 : zend_op *opline = EX(opline);
4066 :
4067 204501 : array_init(&EX_T(opline->result.u.var).tmp_var);
4068 : if (IS_CONST == IS_UNUSED) {
4069 : ZEND_VM_NEXT_OPCODE();
4070 : #if 0 || IS_CONST != IS_UNUSED
4071 : } else {
4072 204501 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4073 : #endif
4074 : }
4075 : }
4076 :
4077 : static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4078 52 : {
4079 52 : zend_op *opline = EX(opline);
4080 :
4081 :
4082 52 : add_function(&EX_T(opline->result.u.var).tmp_var,
4083 : &opline->op1.u.constant,
4084 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4085 :
4086 :
4087 52 : ZEND_VM_NEXT_OPCODE();
4088 : }
4089 :
4090 : static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4091 104 : {
4092 104 : zend_op *opline = EX(opline);
4093 :
4094 :
4095 104 : sub_function(&EX_T(opline->result.u.var).tmp_var,
4096 : &opline->op1.u.constant,
4097 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4098 :
4099 :
4100 104 : ZEND_VM_NEXT_OPCODE();
4101 : }
4102 :
4103 : static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4104 2111 : {
4105 2111 : zend_op *opline = EX(opline);
4106 :
4107 :
4108 2111 : mul_function(&EX_T(opline->result.u.var).tmp_var,
4109 : &opline->op1.u.constant,
4110 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4111 :
4112 :
4113 2111 : ZEND_VM_NEXT_OPCODE();
4114 : }
4115 :
4116 : static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4117 0 : {
4118 0 : zend_op *opline = EX(opline);
4119 :
4120 :
4121 0 : div_function(&EX_T(opline->result.u.var).tmp_var,
4122 : &opline->op1.u.constant,
4123 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4124 :
4125 :
4126 0 : ZEND_VM_NEXT_OPCODE();
4127 : }
4128 :
4129 : static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4130 0 : {
4131 0 : zend_op *opline = EX(opline);
4132 :
4133 :
4134 0 : mod_function(&EX_T(opline->result.u.var).tmp_var,
4135 : &opline->op1.u.constant,
4136 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4137 :
4138 :
4139 0 : ZEND_VM_NEXT_OPCODE();
4140 : }
4141 :
4142 : static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4143 0 : {
4144 0 : zend_op *opline = EX(opline);
4145 :
4146 :
4147 0 : shift_left_function(&EX_T(opline->result.u.var).tmp_var,
4148 : &opline->op1.u.constant,
4149 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4150 :
4151 :
4152 0 : ZEND_VM_NEXT_OPCODE();
4153 : }
4154 :
4155 : static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4156 0 : {
4157 0 : zend_op *opline = EX(opline);
4158 :
4159 :
4160 0 : shift_right_function(&EX_T(opline->result.u.var).tmp_var,
4161 : &opline->op1.u.constant,
4162 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4163 :
4164 :
4165 0 : ZEND_VM_NEXT_OPCODE();
4166 : }
4167 :
4168 : static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4169 15375 : {
4170 15375 : zend_op *opline = EX(opline);
4171 :
4172 :
4173 15375 : concat_function(&EX_T(opline->result.u.var).tmp_var,
4174 : &opline->op1.u.constant,
4175 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4176 :
4177 :
4178 15375 : ZEND_VM_NEXT_OPCODE();
4179 : }
4180 :
4181 : static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4182 49 : {
4183 49 : zend_op *opline = EX(opline);
4184 :
4185 :
4186 49 : is_identical_function(&EX_T(opline->result.u.var).tmp_var,
4187 : &opline->op1.u.constant,
4188 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4189 :
4190 :
4191 49 : ZEND_VM_NEXT_OPCODE();
4192 : }
4193 :
4194 : static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4195 651 : {
4196 651 : zend_op *opline = EX(opline);
4197 :
4198 651 : zval *result = &EX_T(opline->result.u.var).tmp_var;
4199 :
4200 651 : is_identical_function(result,
4201 : &opline->op1.u.constant,
4202 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4203 651 : Z_LVAL_P(result) = !Z_LVAL_P(result);
4204 :
4205 :
4206 651 : ZEND_VM_NEXT_OPCODE();
4207 : }
4208 :
4209 : static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4210 3159 : {
4211 3159 : zend_op *opline = EX(opline);
4212 :
4213 3159 : zval *result = &EX_T(opline->result.u.var).tmp_var;
4214 :
4215 3159 : compare_function(result,
4216 : &opline->op1.u.constant,
4217 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4218 3159 : ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
4219 :
4220 :
4221 3159 : ZEND_VM_NEXT_OPCODE();
4222 : }
4223 :
4224 : static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4225 121 : {
4226 121 : zend_op *opline = EX(opline);
4227 :
4228 121 : zval *result = &EX_T(opline->result.u.var).tmp_var;
4229 :
4230 121 : compare_function(result,
4231 : &opline->op1.u.constant,
4232 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4233 121 : ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
4234 :
4235 :
4236 121 : ZEND_VM_NEXT_OPCODE();
4237 : }
4238 :
4239 : static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4240 816149 : {
4241 816149 : zend_op *opline = EX(opline);
4242 :
4243 816149 : zval *result = &EX_T(opline->result.u.var).tmp_var;
4244 :
4245 816149 : compare_function(result,
4246 : &opline->op1.u.constant,
4247 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4248 816149 : ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
4249 :
4250 :
4251 816149 : ZEND_VM_NEXT_OPCODE();
4252 : }
4253 :
4254 : static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4255 36060 : {
4256 36060 : zend_op *opline = EX(opline);
4257 :
4258 36060 : zval *result = &EX_T(opline->result.u.var).tmp_var;
4259 :
4260 36060 : compare_function(result,
4261 : &opline->op1.u.constant,
4262 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4263 36060 : ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
4264 :
4265 :
4266 36060 : ZEND_VM_NEXT_OPCODE();
4267 : }
4268 :
4269 : static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4270 0 : {
4271 0 : zend_op *opline = EX(opline);
4272 :
4273 :
4274 0 : bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
4275 : &opline->op1.u.constant,
4276 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4277 :
4278 :
4279 0 : ZEND_VM_NEXT_OPCODE();
4280 : }
4281 :
4282 : static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4283 0 : {
4284 0 : zend_op *opline = EX(opline);
4285 :
4286 :
4287 0 : bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
4288 : &opline->op1.u.constant,
4289 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4290 :
4291 :
4292 0 : ZEND_VM_NEXT_OPCODE();
4293 : }
4294 :
4295 : static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4296 0 : {
4297 0 : zend_op *opline = EX(opline);
4298 :
4299 :
4300 0 : bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
4301 : &opline->op1.u.constant,
4302 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4303 :
4304 :
4305 0 : ZEND_VM_NEXT_OPCODE();
4306 : }
4307 :
4308 : static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4309 0 : {
4310 0 : zend_op *opline = EX(opline);
4311 :
4312 :
4313 0 : boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
4314 : &opline->op1.u.constant,
4315 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4316 :
4317 :
4318 0 : ZEND_VM_NEXT_OPCODE();
4319 : }
4320 :
4321 : static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4322 8 : {
4323 8 : zend_op *opline = EX(opline);
4324 : zval *function_name;
4325 : zend_class_entry *ce;
4326 :
4327 8 : zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
4328 :
4329 : if (IS_CONST == IS_CONST) {
4330 : /* no function found. try a static method in class */
4331 8 : ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
4332 8 : if (!ce) {
4333 0 : zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
4334 : }
4335 8 : EX(called_scope) = ce;
4336 : } else {
4337 : ce = EX_T(opline->op1.u.var).class_entry;
4338 :
4339 : if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
4340 : EX(called_scope) = EG(called_scope);
4341 : } else {
4342 : EX(called_scope) = ce;
4343 : }
4344 : }
4345 : if(IS_CV != IS_UNUSED) {
4346 8 : char *function_name_strval = NULL;
4347 8 : int function_name_strlen = 0;
4348 :
4349 :
4350 : if (IS_CV == IS_CONST) {
4351 : function_name_strval = Z_STRVAL(opline->op2.u.constant);
4352 : function_name_strlen = Z_STRLEN(opline->op2.u.constant);
4353 : } else {
4354 8 : function_name = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
4355 :
4356 8 : if (Z_TYPE_P(function_name) != IS_STRING) {
4357 1 : zend_error_noreturn(E_ERROR, "Function name must be a string");
4358 : } else {
4359 7 : function_name_strval = Z_STRVAL_P(function_name);
4360 7 : function_name_strlen = Z_STRLEN_P(function_name);
4361 : }
4362 : }
4363 :
4364 7 : if (function_name_strval) {
4365 7 : if (ce->get_static_method) {
4366 0 : EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
4367 : } else {
4368 7 : EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
4369 : }
4370 7 : if (!EX(fbc)) {
4371 0 : zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
4372 : }
4373 : }
4374 :
4375 : if (IS_CV != IS_CONST) {
4376 :
4377 : }
4378 : } else {
4379 : if(!ce->constructor) {
4380 : zend_error_noreturn(E_ERROR, "Cannot call constructor");
4381 : }
4382 : if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
4383 : zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
4384 : }
4385 : EX(fbc) = ce->constructor;
4386 : }
4387 :
4388 7 : if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
4389 6 : EX(object) = NULL;
4390 : } else {
4391 1 : if (EG(This) &&
4392 : Z_OBJ_HT_P(EG(This))->get_class_entry &&
4393 : !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
4394 : /* We are calling method of the other (incompatible) class,
4395 : but passing $this. This is done for compatibility with php-4. */
4396 : int severity;
4397 : char *verb;
4398 0 : if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
4399 0 : severity = E_STRICT;
4400 0 : verb = "should not";
4401 : } else {
4402 : /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
4403 0 : severity = E_ERROR;
4404 0 : verb = "cannot";
4405 : }
4406 0 : zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
4407 :
4408 : }
4409 1 : if ((EX(object) = EG(This))) {
4410 0 : Z_ADDREF_P(EX(object));
4411 0 : EX(called_scope) = Z_OBJCE_P(EX(object));
4412 : }
4413 : }
4414 :
4415 7 : ZEND_VM_NEXT_OPCODE();
4416 : }
4417 :
4418 : static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4419 0 : {
4420 0 : zend_op *opline = EX(opline);
4421 0 : int switch_expr_is_overloaded=0;
4422 :
4423 :
4424 : if (IS_CONST==IS_VAR) {
4425 : if (EX_T(opline->op1.u.var).var.ptr_ptr) {
4426 : PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
4427 : } else {
4428 : switch_expr_is_overloaded = 1;
4429 : Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
4430 : }
4431 : }
4432 0 : is_equal_function(&EX_T(opline->result.u.var).tmp_var,
4433 : &opline->op1.u.constant,
4434 : _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC) TSRMLS_CC);
4435 :
4436 0 : if (switch_expr_is_overloaded) {
4437 : /* We only free op1 if this is a string offset,
4438 : * Since if it is a TMP_VAR, it'll be reused by
4439 : * other CASE opcodes (whereas string offsets
4440 : * are allocated at each get_zval_ptr())
4441 : */
4442 :
4443 0 : EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
4444 0 : EX_T(opline->op1.u.var).var.ptr = NULL;
4445 : }
4446 0 : ZEND_VM_NEXT_OPCODE();
4447 : }
4448 :
4449 : static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4450 66 : {
4451 66 : zend_op *opline = EX(opline);
4452 :
4453 66 : zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
4454 : zval *expr_ptr;
4455 66 : zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
4456 :
4457 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
4458 : zval **expr_ptr_ptr = NULL;
4459 :
4460 : if (opline->extended_value) {
4461 : expr_ptr_ptr=NULL;
4462 : expr_ptr = *expr_ptr_ptr;
4463 : } else {
4464 : expr_ptr=&opline->op1.u.constant;
4465 : }
4466 : #else
4467 66 : expr_ptr=&opline->op1.u.constant;
4468 : #endif
4469 :
4470 : if (0) { /* temporary variable */
4471 : zval *new_expr;
4472 :
4473 : ALLOC_ZVAL(new_expr);
4474 : INIT_PZVAL_COPY(new_expr, expr_ptr);
4475 : expr_ptr = new_expr;
4476 : } else {
4477 : #if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
4478 : if (opline->extended_value) {
4479 : SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
4480 : expr_ptr = *expr_ptr_ptr;
4481 : Z_ADDREF_P(expr_ptr);
4482 : } else
4483 : #endif
4484 : if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
4485 : zval *new_expr;
4486 :
4487 66 : ALLOC_ZVAL(new_expr);
4488 66 : INIT_PZVAL_COPY(new_expr, expr_ptr);
4489 66 : expr_ptr = new_expr;
4490 66 : zendi_zval_copy_ctor(*expr_ptr);
4491 : } else {
4492 : Z_ADDREF_P(expr_ptr);
4493 : }
4494 : }
4495 66 : if (offset) {
4496 66 : switch (Z_TYPE_P(offset)) {
4497 : case IS_DOUBLE:
4498 0 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
4499 0 : break;
4500 : case IS_LONG:
4501 : case IS_BOOL:
4502 1 : zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
4503 1 : break;
4504 : case IS_STRING:
4505 55 : zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
4506 55 : break;
4507 : case IS_NULL:
4508 0 : zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
4509 0 : break;
4510 : default:
4511 10 : zend_error(E_WARNING, "Illegal offset type");
4512 10 : zval_ptr_dtor(&expr_ptr);
4513 : /* do nothing */
4514 : break;
4515 : }
4516 :
4517 : } else {
4518 0 : zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
4519 : }
4520 66 : if (opline->extended_value) {
4521 :
4522 : } else {
4523 :
4524 : }
4525 66 : ZEND_VM_NEXT_OPCODE();
4526 : }
4527 :
4528 : static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4529 6 : {
4530 6 : zend_op *opline = EX(opline);
4531 :
4532 6 : array_init(&EX_T(opline->result.u.var).tmp_var);
4533 : if (IS_CONST == IS_UNUSED) {
4534 : ZEND_VM_NEXT_OPCODE();
4535 : #if 0 || IS_CONST != IS_UNUSED
4536 : } else {
4537 6 : return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4538 : #endif
4539 : }
4540 : }
4541 :
4542 : static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4543 0 : {
4544 0 : zend_op *opline = EX(opline);
4545 : zend_free_op free_op1;
4546 :
4547 0 : bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
4548 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) TSRMLS_CC);
4549 0 : zval_dtor(free_op1.var);
4550 0 : ZEND_VM_NEXT_OPCODE();
4551 : }
4552 :
4553 : static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4554 72490 : {
4555 72490 : zend_op *opline = EX(opline);
4556 : zend_free_op free_op1;
4557 :
4558 72490 : boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
4559 : _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) TSRMLS_CC);
4560 72490 : zval_dtor(free_op1.var);
4561 72490 : ZEND_VM_NEXT_OPCODE();
4562 : }
4563 :
4564 : static int ZEND_FASTCALL ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4565 110159 : {
4566 110159 : zend_op *opline = EX(opline);
4567 : zend_free_op free_op1;
4568 : zval z_copy;
4569 110159 : zval *z = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4570 :
4571 110159 : if (IS_TMP_VAR != IS_CONST &&
4572 : Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL &&
4573 : zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
4574 0 : zend_print_variable(&z_copy);
4575 0 : zval_dtor(&z_copy);
4576 : } else {
4577 110159 : zend_print_variable(z);
4578 : }
4579 :
4580 110158 : zval_dtor(free_op1.var);
4581 110158 : ZEND_VM_NEXT_OPCODE();
4582 : }
4583 :
4584 : static int ZEND_FASTCALL ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4585 8389 : {
4586 8389 : zend_op *opline = EX(opline);
4587 :
4588 8389 : Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
4589 8389 : Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
4590 :
4591 8389 : return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4592 : }
4593 :
4594 : static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
4595 2760 : {
4596 2760 : zend_op *opline = EX(opline);
4597 : zend_free_op free_op1;
4598 2760 : zval *varname = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
4599 : zval **retval;
4600 : zval tmp_varname;
4601 : HashTable *target_symbol_table;
4602 :
4603 2760 : if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
4604 0 : tmp_varname = *varname;
4605 0 : zval_copy_ctor(&tmp_varname);
4606 0 : convert_to_string(&tmp_varname);
4607 0 : varname = &tmp_varname;
4608 : }
4609 :
4610 2760 : if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
4611 0 : retval = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0 TSRMLS_CC);
4612 0 : zval_dtor(free_op1.var);
4613 : } else {
4614 2760 : target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
4615 : /*
4616 : if (!target_symbol_table) {
4617 : ZEND_VM_NEXT_OPCODE();
4618 : }
4619 : */
4620 2760 : if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
4621 24 : switch (type) {
4622 : case BP_VAR_R:
4623 : case BP_VAR_UNSET:
4624 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
4625 : /* break missing intentionally */
4626 : case BP_VAR_IS:
4627 0 : retval = &EG(uninitialized_zval_ptr);
4628 0 : break;
4629 : case BP_VAR_RW:
4630 0 : zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
4631 : /* break missing intentionally */
4632 : case BP_VAR_W: {
4633 24 : zval *new_zval = &EG(uninitialized_zval);
4634 :
4635 24 : Z_ADDREF_P(new_zval);
4636 24 : zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
4637 : }
4638 : break;
4639 : EMPTY_SWITCH_DEFAULT_CASE()
4640 : }
4641 : }
4642 2760 : switch (opline->op2.u.EA.type) {
4643 : case ZEND_FETCH_GLOBAL:
4644 : if (IS_TMP_VAR != IS_TMP_VAR) {
4645 : zval_dtor(free_op1.var);
4646 : }
4647 0 : break;
4648 : case ZEND_FETCH_LOCAL:
4649 2760 : zval_dtor(free_op1.var);
4650 2760 : break;
4651 : case ZEND_FETCH_STATIC:
4652 0 : zval_update_constant(retval, (void*) 1 TSRMLS_CC);
4653 : break;
4654 : case ZEND_FETCH_GLOBAL_LOCK:
4655 : if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
4656 : PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
4657 : }
4658 : break;
4659 : }
4660 : }
4661 :
4662 :
4663 2760 : if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
4664 0 : zval_dtor(varname);
4665 : }
4666 2760 : if (!RETURN_VALUE_UNU |
