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