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