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