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