clones/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-09-24 03:17:26 +00:00
Code Issues Packages Projects Releases Wiki Activity
bdf7fc67d8
php-src/Zend/zend_vm_def.h

7411 lines
211 KiB
C
Raw Normal View History

- Added missing header sections.
2005-01-10 14:57:36 +00:00
/*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
bump year
2015-01-15 15:27:30 +00:00
| Copyright (c) 1998-2015 Zend Technologies Ltd. (http://www.zend.com) |
- Added missing header sections.
2005-01-10 14:57:36 +00:00
+----------------------------------------------------------------------+
| This source file is subject to version 2.00 of the Zend license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.zend.com/license/2_00.txt. |
| If you did not receive a copy of the Zend license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@zend.com so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Andi Gutmans <andi@zend.com> |
$id:$ tatgs are removed from generated files to avoid committing of Zend/zend_vm_opcodes.h without real changes.
2005-10-28 06:05:57 +00:00
| Zeev Suraski <zeev@zend.com> |
| Dmitry Stogov <dmitry@zend.com> |
- Added missing header sections.
2005-01-10 14:57:36 +00:00
+----------------------------------------------------------------------+
*/
/* $Id$ */
- Regenerate VM files and add warning about regeneration
2005-06-06 15:17:20 +00:00
/* If you change this file, please regenerate the zend_vm_execute.h and
* zend_vm_opcodes.h files by running:
* php zend_vm_gen.php
*/
Get rid of duplicate handlers (ZEND_ADD_SPEC_TMP_TMP and ZEND_ADD_SPEC_VAR_VAR are absolutely the same).
2014-12-03 15:02:02 +00:00
ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
zval *op1, *op2, *result;
op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
result = EX_VAR(opline->result.var);
fast_long_add_function(result, op1, op2);
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
result = EX_VAR(opline->result.var);
ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
result = EX_VAR(opline->result.var);
ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
result = EX_VAR(opline->result.var);
ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));
ZEND_VM_NEXT_OPCODE();
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
}
if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
}
add_function(EX_VAR(opline->result.var), op1, op2);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (ZEND_ADD_SPEC_TMP_TMP and ZEND_ADD_SPEC_VAR_VAR are absolutely the same).
2014-12-03 15:02:02 +00:00
ZEND_VM_HANDLER(2, ZEND_SUB, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
zval *op1, *op2, *result;
op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
result = EX_VAR(opline->result.var);
fast_long_sub_function(result, op1, op2);
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
result = EX_VAR(opline->result.var);
ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
result = EX_VAR(opline->result.var);
ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
result = EX_VAR(opline->result.var);
ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2)));
ZEND_VM_NEXT_OPCODE();
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
}
if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
}
sub_function(EX_VAR(opline->result.var), op1, op2);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (ZEND_ADD_SPEC_TMP_TMP and ZEND_ADD_SPEC_VAR_VAR are absolutely the same).
2014-12-03 15:02:02 +00:00
ZEND_VM_HANDLER(3, ZEND_MUL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
zval *op1, *op2, *result;
op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
zend_long overflow;
result = EX_VAR(opline->result.var);
ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
result = EX_VAR(opline->result.var);
ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
result = EX_VAR(opline->result.var);
ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
result = EX_VAR(opline->result.var);
ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2)));
ZEND_VM_NEXT_OPCODE();
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
}
if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
}
mul_function(EX_VAR(opline->result.var), op1, op2);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (ZEND_ADD_SPEC_TMP_TMP and ZEND_ADD_SPEC_VAR_VAR are absolutely the same).
2014-12-03 15:02:02 +00:00
ZEND_VM_HANDLER(4, ZEND_DIV, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
fast_div_function(EX_VAR(opline->result.var),
Use better data structures (incomplete)
2014-02-18 21:12:05 +00:00
GET_OP1_ZVAL_PTR(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(5, ZEND_MOD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
zval *op1, *op2, *result;
op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
result = EX_VAR(opline->result.var);
if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
// TODO: change into exception ???
SAVE_OPLINE();
zend_error(E_WARNING, "Division by zero");
ZVAL_FALSE(result);
} else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
/* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
ZVAL_LONG(result, 0);
} else {
ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
}
ZEND_VM_NEXT_OPCODE();
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
}
if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
}
mod_function(EX_VAR(opline->result.var), op1, op2);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(6, ZEND_SL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
shift_left_function(EX_VAR(opline->result.var),
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
GET_OP1_ZVAL_PTR(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(7, ZEND_SR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
shift_right_function(EX_VAR(opline->result.var),
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
GET_OP1_ZVAL_PTR(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
concat_function(EX_VAR(opline->result.var),
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
GET_OP1_ZVAL_PTR(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(15, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Split IS_BOOL into IS_FALSE and IS_TRUE
2014-04-30 14:32:42 +00:00
fast_is_identical_function(EX_VAR(opline->result.var),
Use better data structures (incomplete; able to run bench.php)
2014-02-18 12:27:38 +00:00
GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(16, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *result = EX_VAR(opline->result.var);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Split IS_BOOL into IS_FALSE and IS_TRUE
2014-04-30 14:32:42 +00:00
fast_is_not_identical_function(result,
Use better data structures (incomplete; able to run bench.php)
2014-02-18 12:27:38 +00:00
GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (ZEND_ADD_SPEC_TMP_TMP and ZEND_ADD_SPEC_VAR_VAR are absolutely the same).
2014-12-03 15:02:02 +00:00
ZEND_VM_HANDLER(17, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
zval *op1, *op2, *result;
op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_LVAL_P(op1) == Z_LVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
ZVAL_BOOL(EX_VAR(opline->result.var), (double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_DVAL_P(op1) == Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
if (Z_STR_P(op1) == Z_STR_P(op2)) {
ZVAL_TRUE(EX_VAR(opline->result.var));
FREE_OP1();
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
} else if (Z_STRVAL_P(op1)[0] > '9' || Z_STRVAL_P(op2)[0] > '9') {
if (Z_STRLEN_P(op1) != Z_STRLEN_P(op2)) {
ZVAL_FALSE(EX_VAR(opline->result.var));
FREE_OP1();
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
} else {
ZVAL_BOOL(EX_VAR(opline->result.var), memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) == 0);
FREE_OP1();
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
}
} else {
ZVAL_BOOL(EX_VAR(opline->result.var), zendi_smart_strcmp(op1, op2) == 0);
FREE_OP1();
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
}
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
}
if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
}
result = EX_VAR(opline->result.var);
compare_function(result, op1, op2);
ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (ZEND_ADD_SPEC_TMP_TMP and ZEND_ADD_SPEC_VAR_VAR are absolutely the same).
2014-12-03 15:02:02 +00:00
ZEND_VM_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
zval *op1, *op2, *result;
op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_LVAL_P(op1) != Z_LVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
ZVAL_BOOL(EX_VAR(opline->result.var), (double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_DVAL_P(op1) != Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
if (Z_STR_P(op1) == Z_STR_P(op2)) {
ZVAL_FALSE(EX_VAR(opline->result.var));
FREE_OP1();
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
} else if (Z_STRVAL_P(op1)[0] > '9' || Z_STRVAL_P(op2)[0] > '9') {
if (Z_STRLEN_P(op1) != Z_STRLEN_P(op2)) {
ZVAL_TRUE(EX_VAR(opline->result.var));
FREE_OP1();
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
} else {
ZVAL_BOOL(EX_VAR(opline->result.var), memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) != 0);
FREE_OP1();
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
}
} else {
ZVAL_BOOL(EX_VAR(opline->result.var), zendi_smart_strcmp(op1, op2) != 0);
FREE_OP1();
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
}
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
}
if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
}
result = EX_VAR(opline->result.var);
compare_function(result, op1, op2);
ZVAL_BOOL(result, Z_LVAL_P(result) != 0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (ZEND_ADD_SPEC_TMP_TMP and ZEND_ADD_SPEC_VAR_VAR are absolutely the same).
2014-12-03 15:02:02 +00:00
ZEND_VM_HANDLER(19, ZEND_IS_SMALLER, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
zval *op1, *op2, *result;
op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_LVAL_P(op1) < Z_LVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
ZVAL_BOOL(EX_VAR(opline->result.var), (double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_DVAL_P(op1) < Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
ZEND_VM_NEXT_OPCODE();
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
}
if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
}
result = EX_VAR(opline->result.var);
compare_function(result, op1, op2);
ZVAL_BOOL(result, Z_LVAL_P(result) < 0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (ZEND_ADD_SPEC_TMP_TMP and ZEND_ADD_SPEC_VAR_VAR are absolutely the same).
2014-12-03 15:02:02 +00:00
ZEND_VM_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
zval *op1, *op2, *result;
op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_LVAL_P(op1) <= Z_LVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
ZVAL_BOOL(EX_VAR(opline->result.var), (double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_DVAL_P(op1) <= Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
ZEND_VM_NEXT_OPCODE();
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
}
if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
}
result = EX_VAR(opline->result.var);
compare_function(result, op1, op2);
ZVAL_BOOL(result, Z_LVAL_P(result) <= 0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Blast off to space.
2015-01-19 07:12:39 +00:00
ZEND_VM_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
{
USE_OPLINE
zend_free_op free_op1, free_op2;
zval *result = EX_VAR(opline->result.var);
SAVE_OPLINE();
compare_function(result,
GET_OP1_ZVAL_PTR(BP_VAR_R),
GET_OP2_ZVAL_PTR(BP_VAR_R));
FREE_OP1();
FREE_OP2();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(9, ZEND_BW_OR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
bitwise_or_function(EX_VAR(opline->result.var),
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
GET_OP1_ZVAL_PTR(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(10, ZEND_BW_AND, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
bitwise_and_function(EX_VAR(opline->result.var),
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
GET_OP1_ZVAL_PTR(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(11, ZEND_BW_XOR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
bitwise_xor_function(EX_VAR(opline->result.var),
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
GET_OP1_ZVAL_PTR(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(14, ZEND_BOOL_XOR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
boolean_xor_function(EX_VAR(opline->result.var),
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
GET_OP1_ZVAL_PTR(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(12, ZEND_BW_NOT, CONST|TMPVAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
bitwise_not_function(EX_VAR(opline->result.var),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP1_ZVAL_PTR(BP_VAR_R));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_HANDLER(13, ZEND_BOOL_NOT, CONST|TMPVAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
zval *val;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
val = GET_OP1_ZVAL_PTR(BP_VAR_R);
trailing whitespace removal
2015-01-03 09:22:58 +00:00
if (Z_TYPE_P(val) == IS_TRUE) {
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZVAL_FALSE(EX_VAR(opline->result.var));
} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
ZVAL_TRUE(EX_VAR(opline->result.var));
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
FREE_OP1();
CHECK_EXCEPTION();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Use fastcall calling convention for most critical ZE subsystems.
2015-03-13 18:10:09 +00:00
ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV, binary_op_type binary_op)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2, free_op_data1;
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
zval *object;
zval *property;
Temporary fix for lazy symbol table initialization called from zemd_error(), that converts CV variables into IS_INDIRECT
2014-03-05 11:33:31 +00:00
zval *value;
Simplification
2014-10-20 20:56:48 +00:00
zval *zptr;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
SAVE_OPLINE();
object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
property = GET_OP2_ZVAL_PTR(BP_VAR_R);
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
FREE_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Fixed bug #47704 (crashes on some "bad" operations with string offsets) Removed unnecessary checks
2009-03-18 12:53:17 +00:00
}
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
do {
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
simplified code
2014-12-09 09:17:55 +00:00
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
Fixed compilation warnings
2015-02-25 20:20:47 +00:00
ZVAL_DEREF(object);
if (UNEXPECTED(!make_real_object(object))) {
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
zend_error(E_WARNING, "Attempt to assign property of non-object");
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
ZVAL_NULL(EX_VAR(opline->result.var));
}
break;
}
}
Temporary fix for lazy symbol table initialization called from zemd_error(), that converts CV variables into IS_INDIRECT
2014-03-05 11:33:31 +00:00
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* here we are sure we are dealing with an object */
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
&& EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
Simplification
2014-10-20 20:56:48 +00:00
ZVAL_DEREF(zptr);
SEPARATE_ZVAL_NOREF(zptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
binary_op(zptr, zptr, value);
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Simplification
2014-10-20 20:56:48 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), zptr);
}
} else {
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
zval *z;
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 07:49:02 +00:00
zval rv, obj;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Merge branch 'PHP-5.6'
2015-03-10 09:18:54 +00:00
ZVAL_OBJ(&obj, Z_OBJ_P(object));
Z_ADDREF(obj);
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 07:49:02 +00:00
if (Z_OBJ_HT(obj)->read_property &&
(z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
- MFH missing bits and pieces of the partial sync with head # This time i added: # ZEND_FE_RESET_VARIABLE # ZEND_FE_RESET_REFERENCE # and dapted parser,compiler,executor,interfaces to handle these flags # their purpose is to be able to pass whetehr foreach is done by ref to # the current() handler so that it can error out in case it is not capable # to comply to the requested return signature/protocol/semantics (weyp).
2006-05-11 21:07:39 +00:00
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
Fixed zend_object_get_t in simpleXML
2014-04-15 03:05:03 +00:00
zval rv;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
MFH: Added macros for managing zval refcounts and is_ref statuses
2007-10-07 05:22:07 +00:00
if (Z_REFCOUNT_P(z) == 0) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_objects_store_del(Z_OBJ_P(z));
Fix certain operations to stop relying on presence of read_property and write_property handlers. They may be NULL'ed out by certain objects pretending to be pure arrays, for example. Do checks first.
2005-04-15 17:15:18 +00:00
}
Fixed zend_object_get_t in simpleXML
2014-04-15 03:05:03 +00:00
ZVAL_COPY_VALUE(z, value);
Fix certain operations to stop relying on presence of read_property and write_property handlers. They may be NULL'ed out by certain objects pretending to be pure arrays, for example. Do checks first.
2005-04-15 17:15:18 +00:00
}
Fixed bug #69201 (Memory leak using iterator and get by reference on PHP 7)
2015-03-08 12:22:02 +00:00
zptr = z;
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
ZVAL_DEREF(z);
SEPARATE_ZVAL_NOREF(z);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
binary_op(z, z, value);
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 07:49:02 +00:00
Z_OBJ_HT(obj)->write_property(&obj, property, z, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), z);
Fix certain operations to stop relying on presence of read_property and write_property handlers. They may be NULL'ed out by certain objects pretending to be pure arrays, for example. Do checks first.
2005-04-15 17:15:18 +00:00
}
Fixed bug #69201 (Memory leak using iterator and get by reference on PHP 7)
2015-03-08 12:22:02 +00:00
zval_ptr_dtor(zptr);
Fix certain operations to stop relying on presence of read_property and write_property handlers. They may be NULL'ed out by certain objects pretending to be pure arrays, for example. Do checks first.
2005-04-15 17:15:18 +00:00
} else {
zend_error(E_WARNING, "Attempt to assign property of non-object");
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_NULL(EX_VAR(opline->result.var));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
Merge branch 'PHP-5.6'
2015-03-10 09:18:54 +00:00
OBJ_RELEASE(Z_OBJ(obj));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
} while (0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Fixed memory leaks
2014-12-19 16:43:17 +00:00
FREE_OP(free_op_data1);
FREE_OP2();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
/* assign_obj has two opcodes! */
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
Use fastcall calling convention for most critical ZE subsystems.
2015-03-13 18:10:09 +00:00
ZEND_VM_HELPER_EX(zend_binary_assign_op_dim_helper, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV, binary_op_type binary_op)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Optimized ASSIGN_DIM and related opcodes
2014-10-21 15:30:43 +00:00
zend_free_op free_op1, free_op2, free_op_data1;
zval *var_ptr, rv;
Removed useless handlers
2014-12-06 00:03:48 +00:00
zval *value, *container, *dim;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
FREE_UNFETCHED_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Optimized ASSIGN_DIM and related opcodes
2014-10-21 15:30:43 +00:00
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
do {
if (OP1_TYPE == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
if (OP1_TYPE != IS_UNUSED) {
ZVAL_DEREF(container);
}
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
if (OP1_TYPE == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
break;
}
#endif
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_fetch_dimension_address_RW(&rv, container, dim, OP2_TYPE);
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
var_ptr = Z_INDIRECT(rv);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
if (UNEXPECTED(var_ptr == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
FREE_OP2();
FREE_OP(free_op_data1);
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
if (UNEXPECTED(var_ptr == &EG(error_zval))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
} else {
ZVAL_DEREF(var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
binary_op(var_ptr, var_ptr, value);
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
}
Avoid "goto"
2014-10-21 07:43:13 +00:00
}
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
} while (0);
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP2();
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
FREE_OP(free_op_data1);
FREE_OP1_VAR_PTR();
CHECK_EXCEPTION();
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Use fastcall calling convention for most critical ZE subsystems.
2015-03-13 18:10:09 +00:00
ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|CV, CONST|TMPVAR|CV, binary_op_type binary_op)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
{
USE_OPLINE
zend_free_op free_op1, free_op2;
zval *var_ptr;
zval *value;
SAVE_OPLINE();
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
value = GET_OP2_ZVAL_PTR(BP_VAR_R);
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
FREE_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
}
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
Avoid "goto"
2014-10-21 07:43:13 +00:00
} else {
ZVAL_DEREF(var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
binary_op(var_ptr, var_ptr, value);
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
Avoid "goto"
2014-10-21 07:43:13 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
FREE_OP2();
FREE_OP1_VAR_PTR();
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(23, ZEND_ASSIGN_ADD, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, add_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, add_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, add_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, add_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(24, ZEND_ASSIGN_SUB, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, sub_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, sub_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, sub_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, sub_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(25, ZEND_ASSIGN_MUL, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mul_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, mul_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, mul_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, mul_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(26, ZEND_ASSIGN_DIV, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, div_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, div_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, div_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, div_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(27, ZEND_ASSIGN_MOD, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mod_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, mod_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, mod_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, mod_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(28, ZEND_ASSIGN_SL, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_left_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, shift_left_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, shift_left_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, shift_left_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(29, ZEND_ASSIGN_SR, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_right_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, shift_right_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, shift_right_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, shift_right_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(30, ZEND_ASSIGN_CONCAT, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, concat_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, concat_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, concat_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, concat_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(31, ZEND_ASSIGN_BW_OR, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_or_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_or_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, bitwise_or_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_or_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(32, ZEND_ASSIGN_BW_AND, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_and_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_and_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, bitwise_and_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_and_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(33, ZEND_ASSIGN_BW_XOR, VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
#if !defined(ZEND_VM_SPEC) || (OP2_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
USE_OPLINE
Removed useless handlers
2014-12-06 00:03:48 +00:00
# if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
if (EXPECTED(opline->extended_value == 0)) {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_xor_function);
Removed useless handlers
2014-12-06 00:03:48 +00:00
}
# endif
if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_xor_function);
Fixed typo
2014-04-22 09:11:07 +00:00
} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
Optimized ASSIGN_OP
2014-04-07 22:25:49 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, bitwise_xor_function);
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
#else
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_xor_function);
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV, incdec_t incdec_op)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
zval *object;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *property;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *retval;
Simplification
2014-10-20 20:56:48 +00:00
zval *zptr;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
property = GET_OP2_ZVAL_PTR(BP_VAR_R);
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
retval = EX_VAR(opline->result.var);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
FREE_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Fixed bug #47704 (crashes on some "bad" operations with string offsets) Removed unnecessary checks
2009-03-18 12:53:17 +00:00
}
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
do {
if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
Fixed compilation warnings
2015-02-25 20:20:47 +00:00
ZVAL_DEREF(object);
if (UNEXPECTED(!make_real_object(object))) {
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
ZVAL_NULL(retval);
}
break;
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
/* here we are sure we are dealing with an object */
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
&& EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
ZVAL_DEREF(zptr);
SEPARATE_ZVAL_NOREF(zptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
incdec_op(zptr);
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
ZVAL_COPY(retval, zptr);
}
} else {
zval rv;
Refactored read_property() and read_dimension() handlers
2014-02-27 11:40:13 +00:00
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 07:49:02 +00:00
zval *z, obj;
Merge branch 'PHP-5.6'
2015-03-10 09:18:54 +00:00
ZVAL_OBJ(&obj, Z_OBJ_P(object));
Z_ADDREF(obj);
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 07:49:02 +00:00
z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
zval rv;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
if (Z_REFCOUNT_P(z) == 0) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_objects_store_del(Z_OBJ_P(z));
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
}
ZVAL_COPY_VALUE(z, value);
}
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
ZVAL_DEREF(z);
SEPARATE_ZVAL_NOREF(z);
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
incdec_op(z);
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
ZVAL_COPY(retval, z);
}
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 07:49:02 +00:00
Z_OBJ_HT(obj)->write_property(&obj, property, z, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
Merge branch 'PHP-5.6'
2015-03-10 09:18:54 +00:00
OBJ_RELEASE(Z_OBJ(obj));
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
zval_ptr_dtor(z);
} else {
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
ZVAL_NULL(retval);
Fix certain operations to stop relying on presence of read_property and write_property handlers. They may be NULL'ed out by certain objects pretending to be pure arrays, for example. Do checks first.
2005-04-15 17:15:18 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
} while (0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(132, ZEND_PRE_INC_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_pre_incdec_property_helper, incdec_op, increment_function);
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(133, ZEND_PRE_DEC_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_pre_incdec_property_helper, incdec_op, decrement_function);
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV, incdec_t incdec_op)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
zval *object;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *property;
zval *retval;
Simplification
2014-10-20 20:56:48 +00:00
zval *zptr;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
property = GET_OP2_ZVAL_PTR(BP_VAR_R);
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
retval = EX_VAR(opline->result.var);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
FREE_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Fixed bug #47704 (crashes on some "bad" operations with string offsets) Removed unnecessary checks
2009-03-18 12:53:17 +00:00
}
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
do {
if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
Fixed compilation warnings
2015-02-25 20:20:47 +00:00
ZVAL_DEREF(object);
if (UNEXPECTED(!make_real_object(object))) {
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
ZVAL_NULL(retval);
break;
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
/* here we are sure we are dealing with an object */
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
&& EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
ZVAL_DEREF(zptr);
ZVAL_COPY_VALUE(retval, zptr);
zval_opt_copy_ctor(zptr);
incdec_op(zptr);
} else {
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 07:49:02 +00:00
zval rv, obj;
zval *z;
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
zval z_copy;
Merge branch 'PHP-5.6'
2015-03-10 09:18:54 +00:00
ZVAL_OBJ(&obj, Z_OBJ_P(object));
Z_ADDREF(obj);
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 07:49:02 +00:00
z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
zval rv;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
if (Z_REFCOUNT_P(z) == 0) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_objects_store_del(Z_OBJ_P(z));
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
}
ZVAL_COPY_VALUE(z, value);
Fix certain operations to stop relying on presence of read_property and write_property handlers. They may be NULL'ed out by certain objects pretending to be pure arrays, for example. Do checks first.
2005-04-15 17:15:18 +00:00
}
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
ZVAL_DUP(retval, z);
ZVAL_DUP(&z_copy, z);
incdec_op(&z_copy);
if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 07:49:02 +00:00
Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
Merge branch 'PHP-5.6'
2015-03-10 09:18:54 +00:00
OBJ_RELEASE(Z_OBJ(obj));
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(z);
} else {
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
ZVAL_NULL(retval);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
Move ZVAL_DEREF() and make_real_object() into slow paths.
2014-12-09 00:05:06 +00:00
} while (0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(134, ZEND_POST_INC_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_post_incdec_property_helper, incdec_op, increment_function);
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(135, ZEND_POST_DEC_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_post_incdec_property_helper, incdec_op, decrement_function);
}
ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *var_ptr;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
SAVE_OPLINE();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
}
master renames phase 1
2014-08-25 17:24:55 +00:00
if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
fast_long_increment_function(var_ptr);
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Fast path for pre/post inc/dec
2014-04-21 17:38:44 +00:00
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
}
ZEND_VM_NEXT_OPCODE();
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_NULL(EX_VAR(opline->result.var));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
ZEND_VM_NEXT_OPCODE();
}
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
SAVE_OPLINE();
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
var_ptr = GET_OP1_UNDEF_CV(var_ptr, BP_VAR_RW);
}
Fixed reference handling
2014-06-11 23:14:57 +00:00
ZVAL_DEREF(var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Optimized (PRE|POST)_(INC|DEC) handlers. Moved proxy object handling into helper function.
2014-09-25 09:42:46 +00:00
increment_function(var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *var_ptr;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
SAVE_OPLINE();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
}
master renames phase 1
2014-08-25 17:24:55 +00:00
if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
fast_long_decrement_function(var_ptr);
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Fast path for pre/post inc/dec
2014-04-21 17:38:44 +00:00
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
}
ZEND_VM_NEXT_OPCODE();
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_NULL(EX_VAR(opline->result.var));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
ZEND_VM_NEXT_OPCODE();
}
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
SAVE_OPLINE();
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
var_ptr = GET_OP1_UNDEF_CV(var_ptr, BP_VAR_RW);
}
Fixed reference handling
2014-06-11 23:14:57 +00:00
ZVAL_DEREF(var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Optimized (PRE|POST)_(INC|DEC) handlers. Moved proxy object handling into helper function.
2014-09-25 09:42:46 +00:00
decrement_function(var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Optimized (PRE|POST)_(INC|DEC) handlers. Moved proxy object handling into helper function.
2014-09-25 09:42:46 +00:00
zval *var_ptr;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
SAVE_OPLINE();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
}
master renames phase 1
2014-08-25 17:24:55 +00:00
if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
Fast path for pre/post inc/dec
2014-04-21 17:38:44 +00:00
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
fast_long_increment_function(var_ptr);
Fast path for pre/post inc/dec
2014-04-21 17:38:44 +00:00
ZEND_VM_NEXT_OPCODE();
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
ZVAL_NULL(EX_VAR(opline->result.var));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
SAVE_OPLINE();
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
var_ptr = GET_OP1_UNDEF_CV(var_ptr, BP_VAR_RW);
}
Improved POST INC/DEC
2014-12-02 23:47:03 +00:00
ZVAL_DEREF(var_ptr);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
zval_opt_copy_ctor(var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Optimized (PRE|POST)_(INC|DEC) handlers. Moved proxy object handling into helper function.
2014-09-25 09:42:46 +00:00
increment_function(var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Optimized (PRE|POST)_(INC|DEC) handlers. Moved proxy object handling into helper function.
2014-09-25 09:42:46 +00:00
zval *var_ptr;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
SAVE_OPLINE();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
}
master renames phase 1
2014-08-25 17:24:55 +00:00
if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
Fast path for pre/post inc/dec
2014-04-21 17:38:44 +00:00
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
fast_long_decrement_function(var_ptr);
Fast path for pre/post inc/dec
2014-04-21 17:38:44 +00:00
ZEND_VM_NEXT_OPCODE();
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
ZVAL_NULL(EX_VAR(opline->result.var));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
SAVE_OPLINE();
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
var_ptr = GET_OP1_UNDEF_CV(var_ptr, BP_VAR_RW);
}
Improved POST INC/DEC
2014-12-02 23:47:03 +00:00
ZVAL_DEREF(var_ptr);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
zval_opt_copy_ctor(var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Optimized (PRE|POST)_(INC|DEC) handlers. Moved proxy object handling into helper function.
2014-09-25 09:42:46 +00:00
decrement_function(var_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Improved ECHO and PRINT
2014-12-05 12:07:49 +00:00
ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMPVAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *z;
SAVE_OPLINE();
Improved ECHO and PRINT
2014-12-05 12:07:49 +00:00
z = GET_OP1_ZVAL_PTR(BP_VAR_R);
Missing handling of IS_REF in ext/standard/tests/strings/bug47842.php
2014-02-23 11:36:38 +00:00
Improved ECHO and PRINT
2014-12-05 12:07:49 +00:00
if (Z_TYPE_P(z) == IS_STRING) {
zend_string *str = Z_STR_P(z);
if (str->len != 0) {
zend_write(str->val, str->len);
}
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_string *str = _zval_get_string_func(z);
Improved ECHO and PRINT
2014-12-05 12:07:49 +00:00
if (str->len != 0) {
zend_write(str->val, str->len);
}
zend_string_release(str);
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMPVAR|CV, UNUSED|CONST|VAR, int type)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *varname;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *retval;
cleanup
2014-06-02 20:36:31 +00:00
zend_string *name;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
HashTable *target_symbol_table;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
cleanup
2014-06-02 20:36:31 +00:00
if (OP1_TYPE == IS_CONST) {
name = Z_STR_P(varname);
} else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
name = Z_STR_P(varname);
master renames phase 1
2014-08-25 17:24:55 +00:00
zend_string_addref(name);
cleanup
2014-06-02 20:36:31 +00:00
} else {
name = zval_get_string(varname);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Optimized access to static properties using executor specialization. A constant class name may be used as a direct operand of ZEND_FETCH_* instruction without previous ZEND_FETCH_CLASS.
2010-05-06 10:27:35 +00:00
if (OP2_TYPE != IS_UNUSED) {
zend_class_entry *ce;
if (OP2_TYPE == IS_CONST) {
Improved access to static property. Now we cache pointers to zval instead of pointers to property_info.
2015-01-13 00:32:51 +00:00
if (OP1_TYPE == IS_CONST && CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) {
ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
retval = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)) + sizeof(void*));
Improved access to static property. Now we cache pointers to zval instead of pointers to property_info.
2015-01-13 00:32:51 +00:00
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name->val, name->val);
}
Handle run-time cache for static properties directly in executor. Removed cache_slot argument in zend_std_get_static_property() and zend_std_unset_static_property().
2015-01-13 06:33:15 +00:00
ZEND_VM_C_GOTO(fetch_var_return);
Improved access to static property. Now we cache pointers to zval instead of pointers to property_info.
2015-01-13 00:32:51 +00:00
} else if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0);
Fixed bug #61011 (Crash when an exception is thrown by __autoload accessing a static property)
2012-02-25 13:56:59 +00:00
if (UNEXPECTED(ce == NULL)) {
Optimized ZEND_FETCH_R and family
2014-04-07 20:38:54 +00:00
if (OP1_TYPE != IS_CONST) {
master renames phase 1
2014-08-25 17:24:55 +00:00
zend_string_release(name);
Fixed bug #61011 (Crash when an exception is thrown by __autoload accessing a static property)
2012-02-25 13:56:59 +00:00
}
FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
Optimized access to static properties using executor specialization. A constant class name may be used as a direct operand of ZEND_FETCH_* instruction without previous ZEND_FETCH_CLASS.
2010-05-06 10:27:35 +00:00
} else {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ce = Z_CE_P(EX_VAR(opline->op2.var));
Handle run-time cache for static properties directly in executor. Removed cache_slot argument in zend_std_get_static_property() and zend_std_unset_static_property().
2015-01-13 06:33:15 +00:00
if (OP1_TYPE == IS_CONST &&
(retval = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce)) != NULL) {
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name->val, name->val);
}
ZEND_VM_C_GOTO(fetch_var_return);
}
}
retval = zend_std_get_static_property(ce, name, 0);
if (OP1_TYPE == IS_CONST && retval) {
CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce, retval);
Optimized access to static properties using executor specialization. A constant class name may be used as a direct operand of ZEND_FETCH_* instruction without previous ZEND_FETCH_CLASS.
2010-05-06 10:27:35 +00:00
}
Handle run-time cache for static properties directly in executor. Removed cache_slot argument in zend_std_get_static_property() and zend_std_unset_static_property().
2015-01-13 06:33:15 +00:00
Fixed memleak in tests/lang/engine_assignExecutionOrder_001.phpt
2009-09-21 13:01:17 +00:00
FREE_OP1();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
cleanup
2014-06-02 20:36:31 +00:00
retval = zend_hash_find(target_symbol_table, name);
Optimized ZEND_FETCH_R and family
2014-04-07 20:38:54 +00:00
if (retval == NULL) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
switch (type) {
case BP_VAR_R:
case BP_VAR_UNSET:
cleanup
2014-06-02 20:36:31 +00:00
zend_error(E_NOTICE,"Undefined variable: %s", name->val);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* break missing intentionally */
case BP_VAR_IS:
We don't have to check for undefined CV if we fetch it for isset() operation
2014-09-16 05:15:47 +00:00
retval = &EG(uninitialized_zval);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
break;
case BP_VAR_RW:
cleanup
2014-06-02 20:36:31 +00:00
zend_error(E_NOTICE,"Undefined variable: %s", name->val);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* break missing intentionally */
Review ended Revert "An demo(for review) to show how to fix the problem(symbol table resize)" This reverts commit 60c354510b6731ec8348af9c5e230a4859c7c383.
2014-03-11 06:23:14 +00:00
case BP_VAR_W:
cleanup
2014-06-02 20:36:31 +00:00
retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
Refactored IS_INDIRECT IS_VAR passing between opcodes to avoid reference counting
2014-04-04 15:01:53 +00:00
/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
Cleanup
2014-04-15 21:45:40 +00:00
} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
retval = Z_INDIRECT_P(retval);
if (Z_TYPE_P(retval) == IS_UNDEF) {
switch (type) {
case BP_VAR_R:
case BP_VAR_UNSET:
cleanup
2014-06-02 20:36:31 +00:00
zend_error(E_NOTICE,"Undefined variable: %s", name->val);
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
/* break missing intentionally */
case BP_VAR_IS:
We don't have to check for undefined CV if we fetch it for isset() operation
2014-09-16 05:15:47 +00:00
retval = &EG(uninitialized_zval);
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
break;
case BP_VAR_RW:
cleanup
2014-06-02 20:36:31 +00:00
zend_error(E_NOTICE,"Undefined variable: %s", name->val);
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
/* break missing intentionally */
case BP_VAR_W:
ZVAL_NULL(retval);
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Optimized ZEND_FETCH_R and family
2014-04-07 20:38:54 +00:00
if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
Avoid useles constants update
2014-06-16 19:32:58 +00:00
if (Z_CONSTANT_P(retval)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zval_update_constant(retval, 1);
Avoid useles constants update
2014-06-16 19:32:58 +00:00
}
Optimized ZEND_FETCH_R and family
2014-04-07 20:38:54 +00:00
} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
FREE_OP1();
Review ended Revert "An demo(for review) to show how to fix the problem(symbol table resize)" This reverts commit 60c354510b6731ec8348af9c5e230a4859c7c383.
2014-03-11 06:23:14 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Optimized ZEND_FETCH_R and family
2014-04-07 20:38:54 +00:00
if (OP1_TYPE != IS_CONST) {
master renames phase 1
2014-08-25 17:24:55 +00:00
zend_string_release(name);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fixed test tests/classes/__call_007.php
2014-02-21 13:39:02 +00:00
Handle run-time cache for static properties directly in executor. Removed cache_slot argument in zend_std_get_static_property() and zend_std_unset_static_property().
2015-01-13 06:33:15 +00:00
ZEND_VM_C_LABEL(fetch_var_return):
Optimized ZEND_FETCH_R and family
2014-04-07 20:38:54 +00:00
ZEND_ASSERT(retval != NULL);
if (type == BP_VAR_R || type == BP_VAR_IS) {
Fixed ext/wddx/tests/bug48562.phpt
2014-08-05 19:48:27 +00:00
if (/*type == BP_VAR_R &&*/ Z_ISREF_P(retval) && Z_REFCOUNT_P(retval) == 1) {
ZVAL_UNREF(retval);
}
Optimized ZEND_FETCH_R and family
2014-04-07 20:38:54 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
Use better data structures (incomplete)
2014-02-19 11:34:32 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(80, ZEND_FETCH_R, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_R);
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(83, ZEND_FETCH_W, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_W);
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(86, ZEND_FETCH_RW, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_RW);
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(92, ZEND_FETCH_FUNC_ARG, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (zend_is_by_ref_func_arg_fetch(opline, EX(call))) {
Optimized ZEND_FETCH_R and family
2014-04-07 20:38:54 +00:00
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_W);
} else {
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_R);
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(95, ZEND_FETCH_UNSET, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_UNSET);
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_IS);
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Fixed bug #65969 (Chain assignment with T_LIST failure)
2013-11-27 10:26:34 +00:00
zval *container;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
container = GET_OP1_ZVAL_PTR(BP_VAR_R);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP2();
Fixed list() behavior inconsistency (string handling is disabled for all cases, ArrayAccess objects handling is enabled for all cases, ZEND_FETCH_DIM_TMP_VAR opcode is renamed into ZEND_FETCH_LIST, ZEND_FETCH_ADD_LOCK flag is removed).
2014-10-05 09:02:58 +00:00
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicare FETCH_DIM_* handlers
2014-12-05 10:45:03 +00:00
ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *container;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Move checks for references into slow paths.
2014-12-08 22:09:44 +00:00
container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Additional executor specialization
2008-01-23 17:55:55 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP2();
Get rid of zend_free_op structure (use zval* instead). Get rid of useless TSRMLS arguments.
2014-11-18 06:05:48 +00:00
if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
Fixed dereferencing of value returned from function (foo()[1] = ...)
2014-03-04 13:23:23 +00:00
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicare FETCH_DIM_* handlers
2014-12-05 10:45:03 +00:00
ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *container;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed ArrayAccess behavior
2014-03-06 13:59:17 +00:00
container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Additional executor specialization
2008-01-23 17:55:55 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP2();
Get rid of zend_free_op structure (use zval* instead). Get rid of useless TSRMLS arguments.
2014-11-18 06:05:48 +00:00
if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
Fixed dereferencing of value returned from function (foo()[1] = ...)
2014-03-04 13:23:23 +00:00
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Fixed bug #65969 (Chain assignment with T_LIST failure)
2013-11-27 10:26:34 +00:00
zval *container;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
container = GET_OP1_ZVAL_PTR(BP_VAR_IS);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP2();
Fixed bug #65969 (Chain assignment with T_LIST failure)
2013-11-27 10:26:34 +00:00
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicare FETCH_DIM_* handlers
2014-12-05 10:45:03 +00:00
ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *container;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
- MFH missing bits and pieces of the partial sync with head # This time i added: # ZEND_FE_RESET_VARIABLE # ZEND_FE_RESET_REFERENCE # and dapted parser,compiler,executor,interfaces to handle these flags # their purpose is to be able to pass whetehr foreach is done by ref to # the current() handler so that it can error out in case it is not capable # to comply to the requested return signature/protocol/semantics (weyp).
2006-05-11 21:07:39 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (zend_is_by_ref_func_arg_fetch(opline, EX(call))) {
Handle FUNC_ARG fetches on temporaries
2014-05-31 18:15:55 +00:00
if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use temporary expression in write context");
FREE_UNFETCHED_OP2();
FREE_UNFETCHED_OP1();
HANDLE_EXCEPTION();
Handle FUNC_ARG fetches on temporaries
2014-05-31 18:15:55 +00:00
}
Move checks for references into slow paths.
2014-12-08 22:09:44 +00:00
container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
FREE_UNFETCHED_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Additional executor specialization
2008-01-23 17:55:55 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
Get rid of zend_free_op structure (use zval* instead). Get rid of useless TSRMLS arguments.
2014-11-18 06:05:48 +00:00
if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
Fixed dereferencing of value returned from function (foo()[1] = ...)
2014-03-04 13:23:23 +00:00
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP2();
FREE_OP1_VAR_PTR();
executor optimization
2007-12-14 14:14:50 +00:00
} else {
if (OP2_TYPE == IS_UNUSED) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use [] for reading");
FREE_UNFETCHED_OP2();
FREE_UNFETCHED_OP1();
HANDLE_EXCEPTION();
Fixed bug #43201 (Crash on using unitialized vals and __get/__set)
2007-11-06 14:11:59 +00:00
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
container = GET_OP1_ZVAL_PTR(BP_VAR_R);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP2();
Fixed bug #65969 (Chain assignment with T_LIST failure)
2013-11-27 10:26:34 +00:00
FREE_OP1();
Fixed bug #37144 (PHP crashes trying to assign into property of dead object)
2006-07-19 09:55:19 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicare FETCH_DIM_* handlers
2014-12-05 10:45:03 +00:00
ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *container;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_UNSET);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
FREE_UNFETCHED_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Additional executor specialization
2008-01-23 17:55:55 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP2();
Get rid of zend_free_op structure (use zval* instead). Get rid of useless TSRMLS arguments.
2014-11-18 06:05:48 +00:00
if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
Fixed dereferencing of value returned from function (foo()[1] = ...)
2014-03-04 13:23:23 +00:00
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Refactored IS_INDIRECT IS_VAR passing between opcodes to avoid reference counting
2014-04-04 15:01:53 +00:00
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMP|VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *container;
Fixed bug #47109 (Memory leak on $a->{"a"."b"} when $a is not an object)
2009-01-15 08:48:58 +00:00
zend_free_op free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *offset;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
container = Z_REFVAL_P(container);
if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
ZEND_VM_C_GOTO(fetch_obj_r_no_object);
}
} else {
ZEND_VM_C_GOTO(fetch_obj_r_no_object);
}
trailing whitespace removal
2015-01-03 09:22:58 +00:00
}
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
/* here we are sure we are dealing with an object */
do {
zend_object *zobj = Z_OBJ_P(container);
executor optimization
2007-12-14 14:14:50 +00:00
zval *retval;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
if (OP2_TYPE == IS_CONST &&
EXPECTED(zobj->ce == CACHED_PTR(Z_CACHE_SLOT_P(offset)))) {
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(offset) + sizeof(void*));
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
Fixed compilation warnings
2015-02-25 20:20:47 +00:00
if (EXPECTED(prop_offset != (uint32_t)ZEND_DYNAMIC_PROPERTY_OFFSET)) {
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
retval = OBJ_PROP(zobj, prop_offset);
if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
ZVAL_COPY(EX_VAR(opline->result.var), retval);
break;
}
} else if (EXPECTED(zobj->properties != NULL)) {
retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
if (EXPECTED(retval)) {
ZVAL_COPY(EX_VAR(opline->result.var), retval);
break;
Improved object property access.
2014-11-06 11:50:03 +00:00
}
}
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
if (UNEXPECTED(zobj->handlers->read_property == NULL)) {
ZEND_VM_C_LABEL(fetch_obj_r_no_object):
zend_error(E_NOTICE, "Trying to get property of non-object");
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
retval = zobj->handlers->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var));
Improved object property access.
2014-11-06 11:50:03 +00:00
if (retval != EX_VAR(opline->result.var)) {
ZVAL_COPY(EX_VAR(opline->result.var), retval);
}
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
}
} while (0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *property;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *container;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
property = GET_OP2_ZVAL_PTR(BP_VAR_R);
Move checks for references into slow paths.
2014-12-08 22:09:44 +00:00
container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
FREE_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Additional executor specialization
2008-01-23 17:55:55 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
Get rid of zend_free_op structure (use zval* instead). Get rid of useless TSRMLS arguments.
2014-11-18 06:05:48 +00:00
if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
Fixed dereferencing of value returned from function (foo()[1] = ...)
2014-03-04 13:23:23 +00:00
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *property;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *container;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
property = GET_OP2_ZVAL_PTR(BP_VAR_R);
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
FREE_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Additional executor specialization
2008-01-23 17:55:55 +00:00
}
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
Get rid of zend_free_op structure (use zval* instead). Get rid of useless TSRMLS arguments.
2014-11-18 06:05:48 +00:00
if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
Fixed dereferencing of value returned from function (foo()[1] = ...)
2014-03-04 13:23:23 +00:00
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, CONST|TMPVAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
zend_free_op free_op1;
zval *container;
zend_free_op free_op2;
zval *offset;
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
container = Z_REFVAL_P(container);
if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
ZEND_VM_C_GOTO(fetch_obj_is_no_object);
}
} else {
ZEND_VM_C_GOTO(fetch_obj_is_no_object);
}
trailing whitespace removal
2015-01-03 09:22:58 +00:00
}
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
/* here we are sure we are dealing with an object */
do {
zend_object *zobj = Z_OBJ_P(container);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *retval;
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
if (OP2_TYPE == IS_CONST &&
EXPECTED(zobj->ce == CACHED_PTR(Z_CACHE_SLOT_P(offset)))) {
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(offset) + sizeof(void*));
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
Fixed compilation warnings
2015-02-25 20:20:47 +00:00
if (EXPECTED(prop_offset != (uint32_t)ZEND_DYNAMIC_PROPERTY_OFFSET)) {
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
retval = OBJ_PROP(zobj, prop_offset);
if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
ZVAL_COPY(EX_VAR(opline->result.var), retval);
break;
}
} else if (EXPECTED(zobj->properties != NULL)) {
retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
if (EXPECTED(retval)) {
ZVAL_COPY(EX_VAR(opline->result.var), retval);
break;
Improved object property access.
2014-11-06 11:50:03 +00:00
}
}
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
if (UNEXPECTED(zobj->handlers->read_property == NULL)) {
ZEND_VM_C_LABEL(fetch_obj_is_no_object):
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
retval = zobj->handlers->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var));
Improved object property access.
2014-11-06 11:50:03 +00:00
if (retval != EX_VAR(opline->result.var)) {
ZVAL_COPY(EX_VAR(opline->result.var), retval);
}
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
}
} while (0);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, CONST|TMP|VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *container;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (zend_is_by_ref_func_arg_fetch(opline, EX(call))) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *property;
SAVE_OPLINE();
property = GET_OP2_ZVAL_PTR(BP_VAR_R);
Move checks for references into slow paths.
2014-12-08 22:09:44 +00:00
container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
zend_error(E_EXCEPTION | E_ERROR, "Cannot use temporary expression in write context");
FREE_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
}
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
FREE_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Additional executor specialization
2008-01-23 17:55:55 +00:00
}
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
Get rid of zend_free_op structure (use zval* instead). Get rid of useless TSRMLS arguments.
2014-11-18 06:05:48 +00:00
if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
Fixed dereferencing of value returned from function (foo()[1] = ...)
2014-03-04 13:23:23 +00:00
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
} else {
Removed useless helper
2014-09-23 19:26:39 +00:00
ZEND_VM_DISPATCH_TO_HANDLER(ZEND_FETCH_OBJ_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Refactored IS_INDIRECT IS_VAR passing between opcodes to avoid reference counting
2014-04-04 15:01:53 +00:00
zend_free_op free_op1, free_op2;
Fixed compilation warnings
2014-04-22 13:46:34 +00:00
zval *container, *property;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
property = GET_OP2_ZVAL_PTR(BP_VAR_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
FREE_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Additional executor specialization
2008-01-23 17:55:55 +00:00
}
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
Get rid of zend_free_op structure (use zval* instead). Get rid of useless TSRMLS arguments.
2014-11-18 06:05:48 +00:00
if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
Fixed dereferencing of value returned from function (foo()[1] = ...)
2014-03-04 13:23:23 +00:00
EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_HANDLER(98, ZEND_FETCH_LIST, CONST|TMPVAR|CV, CONST)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *container;
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
container = GET_OP1_ZVAL_PTR(BP_VAR_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_C_LABEL(try_fetch_list):
Fixed list() behavior inconsistency (string handling is disabled for all cases, ArrayAccess objects handling is enabled for all cases, ZEND_FETCH_DIM_TMP_VAR opcode is renamed into ZEND_FETCH_LIST, ZEND_FETCH_ADD_LOCK flag is removed).
2014-10-05 09:02:58 +00:00
if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
Fixed ability to build unspecialized executor
2015-02-26 14:53:03 +00:00
zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), EX_CONSTANT(opline->op2), OP2_TYPE, BP_VAR_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), value);
Fixed list() behavior inconsistency (string handling is disabled for all cases, ArrayAccess objects handling is enabled for all cases, ZEND_FETCH_DIM_TMP_VAR opcode is renamed into ZEND_FETCH_LIST, ZEND_FETCH_ADD_LOCK flag is removed).
2014-10-05 09:02:58 +00:00
} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) &&
EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) {
zval *result = EX_VAR(opline->result.var);
Fixed ability to build unspecialized executor
2015-02-26 14:53:03 +00:00
zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, EX_CONSTANT(opline->op2), BP_VAR_R, result);
Fixed list() behavior inconsistency (string handling is disabled for all cases, ArrayAccess objects handling is enabled for all cases, ZEND_FETCH_DIM_TMP_VAR opcode is renamed into ZEND_FETCH_LIST, ZEND_FETCH_ADD_LOCK flag is removed).
2014-10-05 09:02:58 +00:00
if (retval) {
if (result != retval) {
ZVAL_COPY(result, retval);
}
} else {
ZVAL_NULL(result);
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
} else if (Z_TYPE_P(container) == IS_REFERENCE) {
container = Z_REFVAL_P(container);
ZEND_VM_C_GOTO(try_fetch_list);
Fixed list() behavior inconsistency (string handling is disabled for all cases, ArrayAccess objects handling is enabled for all cases, ZEND_FETCH_DIM_TMP_VAR opcode is renamed into ZEND_FETCH_LIST, ZEND_FETCH_ADD_LOCK flag is removed).
2014-10-05 09:02:58 +00:00
} else {
ZVAL_NULL(EX_VAR(opline->result.var));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
executor optimization
2007-12-14 14:14:50 +00:00
zend_free_op free_op1, free_op2;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *object;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *property_name;
SAVE_OPLINE();
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
object = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
FREE_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Additional executor specialization
2008-01-23 17:55:55 +00:00
}
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, OP1_TYPE, property_name, OP2_TYPE, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property_name)) : NULL));
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
FREE_OP1_VAR_PTR();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* assign_obj has two opcodes! */
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicare FETCH_DIM_* handlers
2014-12-05 10:45:03 +00:00
ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *object_ptr;
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
zend_free_op free_op2, free_op_data1;
zval *value;
zval *variable_ptr;
zval *dim;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
object_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
FREE_UNFETCHED_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
executor optimization
2007-12-14 14:14:50 +00:00
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
ZEND_VM_C_LABEL(try_assign_dim):
if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
ZEND_VM_C_LABEL(try_assign_dim_array):
Improved ASSIGN_DIM handler
2015-02-25 23:49:19 +00:00
if (OP2_TYPE == IS_UNUSED) {
SEPARATE_ARRAY(object_ptr);
variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
if (UNEXPECTED(variable_ptr == NULL)) {
zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
variable_ptr = &EG(error_zval);
}
} else {
dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
SEPARATE_ARRAY(object_ptr);
variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, OP2_TYPE, BP_VAR_W);
FREE_OP2();
}
Pass znode_op structure by value (it fits into one word) instead of pointer to structure.
2014-12-09 00:03:38 +00:00
value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
Use zval_ptr_dtor_nogc() to free IS_TMP_VAR operands. Removed ZEND_SWITCH_FREE opcode (ZEND_FREE used instead).
2014-09-23 13:21:29 +00:00
FREE_OP(free_op_data1);
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
ZVAL_NULL(EX_VAR(opline->result.var));
}
executor optimization
2007-12-14 14:14:50 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type);
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
if ((opline+1)->op1_type == IS_VAR) {
Use zval_ptr_dtor_nogc() to free IS_TMP_VAR operands. Removed ZEND_SWITCH_FREE opcode (ZEND_FREE used instead).
2014-09-23 13:21:29 +00:00
FREE_OP(free_op_data1);
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
}
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), value);
Fixed wrong result of cascading assignment to string offset Fixed memory corruption on cascading assignment of IS_TMP_VAR into string offset Fixed opcode caches shared memory corruption on cascading assignment of IS_CONST into string offset
2008-03-04 10:06:52 +00:00
}
Redesigned SRR_OFFSET handling
2014-02-28 13:39:08 +00:00
}
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
} else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
zend_free_op free_op2;
zval *property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, (opline+1)->op1_type, (opline+1)->op1, execute_data);
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
FREE_OP2();
Improved ASSIGN_DIM handler
2015-02-25 23:49:19 +00:00
} else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) {
zend_long offset;
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
Improved ASSIGN_DIM handler
2015-02-25 23:49:19 +00:00
dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
FREE_OP2();
value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
FREE_OP(free_op_data1);
} else {
zval_ptr_dtor_nogc(object_ptr);
ZEND_VM_C_LABEL(assign_dim_convert_to_array):
ZVAL_NEW_ARR(object_ptr);
zend_hash_init(Z_ARRVAL_P(object_ptr), 8, NULL, ZVAL_PTR_DTOR, 0);
ZEND_VM_C_GOTO(try_assign_dim_array);
}
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
} else if (EXPECTED(Z_ISREF_P(object_ptr))) {
object_ptr = Z_REFVAL_P(object_ptr);
ZEND_VM_C_GOTO(try_assign_dim);
Improved ASSIGN_DIM handler
2015-02-25 23:49:19 +00:00
} else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
if (UNEXPECTED(object_ptr == &EG(error_zval))) {
ZEND_VM_C_GOTO(assign_dim_clean);
}
ZEND_VM_C_GOTO(assign_dim_convert_to_array);
Improved ASSIGN_DIM and ASSIGN_OBJ
2014-12-08 21:10:23 +00:00
} else {
Improved ASSIGN_DIM handler
2015-02-25 23:49:19 +00:00
zend_error(E_WARNING, "Cannot use a scalar value as an array");
ZEND_VM_C_LABEL(assign_dim_clean):
dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
FREE_OP2();
value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
FREE_OP(free_op_data1);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
FREE_OP1_VAR_PTR();
/* assign_dim has two opcodes! */
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
executor optimization
2007-12-14 14:14:50 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *value;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *variable_ptr;
executor optimization
2007-12-14 14:14:50 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Simplify ASSIGN code
2014-09-11 13:00:06 +00:00
value = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
Tergets of ASSIGN and ASSIGN_REF don't have to be initialized
2014-04-04 11:22:41 +00:00
variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
fix 64 bit string index usage
2014-09-06 22:54:47 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
Replace IS_OP?_TMP_FREE() with more clear (OP?_TYPE == IS_TMP_VAR)
2014-09-22 08:47:10 +00:00
if (OP2_TYPE == IS_TMP_VAR) {
Use zval_ptr_dtor_nogc() to free IS_TMP_VAR operands. Removed ZEND_SWITCH_FREE opcode (ZEND_FREE used instead).
2014-09-23 13:21:29 +00:00
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
}
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_NULL(EX_VAR(opline->result.var));
Fixed wrong result of cascading assignment to string offset Fixed memory corruption on cascading assignment of IS_TMP_VAR into string offset Fixed opcode caches shared memory corruption on cascading assignment of IS_CONST into string offset
2008-03-04 10:06:52 +00:00
}
executor optimization
2007-12-14 14:14:50 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
value = zend_assign_to_variable(variable_ptr, value, OP2_TYPE);
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), value);
Fixed wrong result of cascading assignment to string offset Fixed memory corruption on cascading assignment of IS_TMP_VAR into string offset Fixed opcode caches shared memory corruption on cascading assignment of IS_CONST into string offset
2008-03-04 10:06:52 +00:00
}
Redesigned SRR_OFFSET handling
2014-02-28 13:39:08 +00:00
FREE_OP1_VAR_PTR();
executor optimization
2007-12-14 14:14:50 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* zend_assign_to_variable() always takes care of op2, never free it! */
FREE_OP2_IF_VAR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *variable_ptr;
zval *value_ptr;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
value_ptr = GET_OP2_ZVAL_PTR_PTR(BP_VAR_W);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Get rid of ZEND_FETCH_MAKE_REF
2014-10-22 17:45:02 +00:00
if (OP2_TYPE == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
FREE_OP2_VAR_PTR();
FREE_UNFETCHED_OP1();
HANDLE_EXCEPTION();
Get rid of ZEND_FETCH_MAKE_REF
2014-10-22 17:45:02 +00:00
}
Fixed bug #31525 (object reference being dropped. $this getting lost)
2005-05-05 17:37:25 +00:00
if (OP2_TYPE == IS_VAR &&
Get rid of ZEND_FETCH_MAKE_REF
2014-10-22 17:45:02 +00:00
(value_ptr == &EG(uninitialized_zval) ||
(opline->extended_value == ZEND_RETURNS_FUNCTION &&
!(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) {
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
if (!OP2_FREE) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
Fixed bug #31525 (object reference being dropped. $this getting lost)
2005-05-05 17:37:25 +00:00
}
- MF44: Problems with user defined error handler and references
2005-06-07 10:01:30 +00:00
zend_error(E_STRICT, "Only variables should be assigned by reference");
Fixed bug #45805 (Crach on throwing exception from error handler)
2008-08-13 07:21:30 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
FREE_OP2_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
HANDLE_EXCEPTION();
Fixed bug #45805 (Crach on throwing exception from error handler)
2008-08-13 07:21:30 +00:00
}
Fixed bug #31525 (object reference being dropped. $this getting lost)
2005-05-05 17:37:25 +00:00
ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ASSIGN);
Fixed bug #32660 (Assignment by reference causes crash when field access is overloaded (__get))
2005-06-23 11:04:35 +00:00
}
Tergets of ASSIGN and ASSIGN_REF don't have to be initialized
2014-04-04 11:22:41 +00:00
variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
Get rid of ZEND_FETCH_MAKE_REF
2014-10-22 17:45:02 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
FREE_OP2_VAR_PTR();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Get rid of ZEND_FETCH_MAKE_REF
2014-10-22 17:45:02 +00:00
}
Fixed IS_INDIRECT handling when assign array element by reference. This might cause passing invalid pointer if the array could be resized before IS_INDIRECT usage. Now we use IS_REFERENCE instead of IS_INDIRECT. The following test crashed before: <?php $a = array(0,1,2,3,4,5,6,7); $a[8] = &$a[7]; ?>
2014-03-12 20:30:53 +00:00
if (OP1_TYPE == IS_VAR &&
UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
ASSIGN_REF optimization
2014-04-03 12:53:30 +00:00
UNEXPECTED(!Z_ISREF_P(variable_ptr))) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot assign by reference to overloaded object");
FREE_OP2_VAR_PTR();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
EG(error_zval) must be passed as IS_INDIRECT
2014-03-04 12:32:40 +00:00
}
ASSIGN_REF optimization
2014-04-03 12:53:30 +00:00
if ((OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
(OP2_TYPE == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
variable_ptr = &EG(uninitialized_zval);
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_assign_to_variable_reference(variable_ptr, value_ptr);
ASSIGN_REF optimization
2014-04-03 12:53:30 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
FREE_OP1_VAR_PTR();
Refactored read_property() and read_dimension() handlers
2014-02-27 11:40:13 +00:00
FREE_OP2_VAR_PTR();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
ZEND_VM_HELPER(zend_leave_helper, ANY, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Microoptimization (avoid reloading from memory)
2015-03-03 13:51:27 +00:00
zend_execute_data *old_execute_data;
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
zend_call_kind call_kind = EX_CALL_KIND();
Fix bug #63822: Crash when using closures with ArrayAccess op_array->T was used after the closure's op_array was already freed. This just swaps the freeing order.
2012-12-21 00:56:37 +00:00
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
if (call_kind == ZEND_CALL_NESTED_FUNCTION) {
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
zend_object *object;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
i_free_compiled_variables(execute_data);
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
if (UNEXPECTED(EX(symbol_table) != NULL)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_clean_and_cache_symbol_table(EX(symbol_table));
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_free_extra_args(execute_data);
Microoptimization (avoid reloading from memory)
2015-03-03 13:51:27 +00:00
old_execute_data = execute_data;
execute_data = EG(current_execute_data) = EX(prev_execute_data);
More accurate reference counting on closures
2015-03-10 20:04:41 +00:00
if (UNEXPECTED(old_execute_data->func->op_array.fn_flags & ZEND_ACC_CLOSURE)) {
Microoptimization (avoid reloading from memory)
2015-03-03 13:51:27 +00:00
OBJ_RELEASE((zend_object*)old_execute_data->func->op_array.prototype);
Fixed delayed closure destruction and reference support
2014-07-10 14:36:11 +00:00
}
Microoptimization (avoid reloading from memory)
2015-03-03 13:51:27 +00:00
object = Z_OBJ(old_execute_data->This);
zend_vm_stack_free_call_frame(old_execute_data);
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (object) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (UNEXPECTED(EG(exception) != NULL) && (EX(opline)->op1.num & ZEND_CALL_CTOR)) {
if (!(EX(opline)->op1.num & ZEND_CALL_CTOR_RESULT_UNUSED)) {
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
GC_REFCOUNT(object)--;
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
}
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (GC_REFCOUNT(object) == 1) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_object_store_ctor_failed(object);
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
}
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
OBJ_RELEASE(object);
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
}
Get rid of EX(scope). In most cases we use EG(scope) anyway. EX(scope) was used to switch EG(scope) back after call, but it's possibleto use EX(func)->common.scope instead.
2014-11-28 07:21:18 +00:00
EG(scope) = EX(func)->op_array.scope;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
Allow CALL executor to keep few very often used vaiables in CPU registers. This is disabled by default yet, but may be enabled compiling zend_execute.c with -DHAVE_GCC_GLOBAL_REGS. Only tested on Linux x86 and x86_64 with GCC 4.9.2.
2015-03-13 00:28:21 +00:00
const zend_op *old_opline = EX(opline);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_throw_exception_internal(NULL);
Allow CALL executor to keep few very often used vaiables in CPU registers. This is disabled by default yet, but may be enabled compiling zend_execute.c with -DHAVE_GCC_GLOBAL_REGS. Only tested on Linux x86 and x86_64 with GCC 4.9.2.
2015-03-13 00:28:21 +00:00
if (RETURN_VALUE_USED(old_opline)) {
zval_ptr_dtor(EX_VAR(old_opline->result.var));
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
HANDLE_EXCEPTION_LEAVE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_isset_isempty_dim_prop_obj_handler() split into separate handlers. (Actually, it shared near nothing)
2014-04-21 20:32:29 +00:00
LOAD_OPLINE();
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
ZEND_VM_INC_OPCODE();
ZEND_VM_LEAVE();
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
} else if (call_kind == ZEND_CALL_NESTED_CODE) {
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
zend_detach_symbol_table(execute_data);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
destroy_op_array(&EX(func)->op_array);
Use efree_size() instead of efree() where posible
2014-08-27 16:49:56 +00:00
efree_size(EX(func), sizeof(zend_op_array));
Microoptimization (avoid reloading from memory)
2015-03-03 13:51:27 +00:00
old_execute_data = execute_data;
execute_data = EG(current_execute_data) = EX(prev_execute_data);
zend_vm_stack_free_call_frame(old_execute_data);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
zend_attach_symbol_table(execute_data);
if (UNEXPECTED(EG(exception) != NULL)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_throw_exception_internal(NULL);
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
HANDLE_EXCEPTION_LEAVE();
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zend_isset_isempty_dim_prop_obj_handler() split into separate handlers. (Actually, it shared near nothing)
2014-04-21 20:32:29 +00:00
LOAD_OPLINE();
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
ZEND_VM_INC_OPCODE();
ZEND_VM_LEAVE();
} else {
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
if (call_kind == ZEND_CALL_TOP_FUNCTION) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
i_free_compiled_variables(execute_data);
Removed EG(active_symbol_table) and use corresponding value from EG(current_execute_data)
2014-07-04 14:03:45 +00:00
if (UNEXPECTED(EX(symbol_table) != NULL)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_clean_and_cache_symbol_table(EX(symbol_table));
Removed EG(active_symbol_table) and use corresponding value from EG(current_execute_data)
2014-07-04 14:03:45 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_free_extra_args(execute_data);
Fixed delayed closure destruction and reference support
2014-07-10 14:36:11 +00:00
EG(current_execute_data) = EX(prev_execute_data);
More accurate reference counting on closures
2015-03-10 20:04:41 +00:00
if (EX(func)->op_array.fn_flags & ZEND_ACC_CLOSURE) {
Fixed delayed closure destruction and reference support
2014-07-10 14:36:11 +00:00
OBJ_RELEASE((zend_object*)EX(func)->op_array.prototype);
code cleanup
2014-07-08 09:24:23 +00:00
}
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
} else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
zend_array *symbol_table = EX(symbol_table);
zend_detach_symbol_table(execute_data);
old_execute_data = EX(prev_execute_data);
while (old_execute_data) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (old_execute_data->func && ZEND_USER_CODE(old_execute_data->func->op_array.type)) {
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
if (old_execute_data->symbol_table == symbol_table) {
zend_attach_symbol_table(old_execute_data);
}
break;
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
old_execute_data = old_execute_data->prev_execute_data;
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
Fixed delayed closure destruction and reference support
2014-07-10 14:36:11 +00:00
EG(current_execute_data) = EX(prev_execute_data);
Improved speed of conditional jump instructions by checking for most useful case (conditional expression)
2009-03-18 14:17:15 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_free_call_frame(execute_data);
trailing whitespace removal
2015-01-03 09:22:58 +00:00
Optimized zend_leave_helper()
2014-04-18 09:46:36 +00:00
ZEND_VM_RETURN();
trailing whitespace removal
2015-01-03 09:22:58 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
ZEND_VM_HANDLER(42, ZEND_JMP, ANY, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op1));
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
ZEND_VM_CONTINUE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMPVAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
zend_free_op free_op1;
zval *val;
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
val = GET_OP1_ZVAL_PTR(BP_VAR_R);
fix UMR when variable name is an object and __toString is used # zend_call_function checks IS_REF on This
2011-03-16 05:25:02 +00:00
trailing whitespace removal
2015-01-03 09:22:58 +00:00
if (Z_TYPE_P(val) == IS_TRUE) {
improved timeout handling on windows
2015-03-16 16:48:29 +00:00
ZEND_VM_SET_NEXT_OPCODE(opline + 1);
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_CONTINUE();
} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
if (OP1_TYPE == IS_CV) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
trailing whitespace removal
2015-01-03 09:22:58 +00:00
} else {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
ZEND_VM_CONTINUE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (i_zend_is_true(val)) {
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
opline++;
} else {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
opline = OP_JMP_ADDR(opline, opline->op2);
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
}
FREE_OP1();
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
ZEND_VM_JMP(opline);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMPVAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
zend_free_op free_op1;
zval *val;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
val = GET_OP1_ZVAL_PTR(BP_VAR_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
if (Z_TYPE_P(val) == IS_TRUE) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_CONTINUE();
} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
if (OP1_TYPE == IS_CV) {
ZEND_VM_NEXT_OPCODE();
trailing whitespace removal
2015-01-03 09:22:58 +00:00
} else {
improved timeout handling on windows
2015-03-16 16:48:29 +00:00
ZEND_VM_SET_NEXT_OPCODE(opline + 1);
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
ZEND_VM_CONTINUE();
LSB parent/self forwarding
2008-07-24 09:42:18 +00:00
}
Namespaces
2007-09-28 19:52:53 +00:00
}
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (i_zend_is_true(val)) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
opline = OP_JMP_ADDR(opline, opline->op2);
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
} else {
opline++;
}
FREE_OP1();
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
ZEND_VM_JMP(opline);
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMPVAR|CV, ANY)
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
{
USE_OPLINE
zend_free_op free_op1;
zval *val;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
SAVE_OPLINE();
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
val = GET_OP1_ZVAL_PTR(BP_VAR_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) {
ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
ZEND_VM_CONTINUE();
} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
if (OP1_TYPE == IS_CV) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
trailing whitespace removal
2015-01-03 09:22:58 +00:00
} else {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
ZEND_VM_CONTINUE();
- MFH Fixed Bug #38064 ignored constructor visibility
2006-08-07 23:24:33 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (i_zend_is_true(val)) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
opline = ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value);
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
} else {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
opline = OP_JMP_ADDR(opline, opline->op2);
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
}
FREE_OP1();
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
ZEND_VM_JMP(opline);
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMPVAR|CV, ANY)
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
{
USE_OPLINE
zend_free_op free_op1;
zval *val;
Fixed memory leak
2015-01-23 17:35:32 +00:00
int ret;
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
SAVE_OPLINE();
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
val = GET_OP1_ZVAL_PTR(BP_VAR_R);
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
if (Z_TYPE_P(val) == IS_TRUE) {
ZVAL_TRUE(EX_VAR(opline->result.var));
improved timeout handling on windows
2015-03-16 16:48:29 +00:00
ZEND_VM_SET_NEXT_OPCODE(opline + 1);
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_CONTINUE();
} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
ZVAL_FALSE(EX_VAR(opline->result.var));
if (OP1_TYPE == IS_CV) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
trailing whitespace removal
2015-01-03 09:22:58 +00:00
} else {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
ZEND_VM_CONTINUE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
Fixed memory leak
2015-01-23 17:35:32 +00:00
ret = i_zend_is_true(val);
FREE_OP1();
if (ret) {
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
ZVAL_TRUE(EX_VAR(opline->result.var));
opline++;
} else {
ZVAL_FALSE(EX_VAR(opline->result.var));
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
opline = OP_JMP_ADDR(opline, opline->op2);
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
ZEND_VM_JMP(opline);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMPVAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
zend_free_op free_op1;
zval *val;
Fixed memory leak
2015-01-23 17:35:32 +00:00
int ret;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
SAVE_OPLINE();
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
val = GET_OP1_ZVAL_PTR(BP_VAR_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
if (Z_TYPE_P(val) == IS_TRUE) {
ZVAL_TRUE(EX_VAR(opline->result.var));
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_CONTINUE();
} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
ZVAL_FALSE(EX_VAR(opline->result.var));
if (OP1_TYPE == IS_CV) {
ZEND_VM_NEXT_OPCODE();
trailing whitespace removal
2015-01-03 09:22:58 +00:00
} else {
improved timeout handling on windows
2015-03-16 16:48:29 +00:00
ZEND_VM_SET_NEXT_OPCODE(opline + 1);
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
ZEND_VM_CONTINUE();
}
}
Fixed memory leak
2015-01-23 17:35:32 +00:00
ret = i_zend_is_true(val);
FREE_OP1();
if (ret) {
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
ZVAL_TRUE(EX_VAR(opline->result.var));
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
opline = OP_JMP_ADDR(opline, opline->op2);
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
} else {
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
ZVAL_FALSE(EX_VAR(opline->result.var));
opline++;
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
JMPZ/JMPNZ/JMPZNZ optimization
2014-04-30 21:24:38 +00:00
ZEND_VM_JMP(opline);
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
- Added indirect method call through array variable (FR Bug #47160)
2011-06-06 21:42:05 +00:00
Get rid of duplicate handlers (ZEND_ADD_SPEC_TMP_TMP and ZEND_ADD_SPEC_VAR_VAR are absolutely the same).
2014-12-03 15:02:02 +00:00
ZEND_VM_HANDLER(70, ZEND_FREE, TMPVAR, ANY)
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
{
USE_OPLINE
WS, merged from trunk cause this issue, sorry
2012-01-26 01:28:37 +00:00
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
SAVE_OPLINE();
Use zval_ptr_dtor_nogc() to free IS_TMP_VAR operands. Removed ZEND_SWITCH_FREE opcode (ZEND_FREE used instead).
2014-09-23 13:21:29 +00:00
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
WS, merged from trunk cause this issue, sorry
2012-01-26 01:28:37 +00:00
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZEND_VM_HANDLER(127, ZEND_FE_FREE, TMPVAR, ANY)
{
zval *var;
USE_OPLINE
SAVE_OPLINE();
var = EX_VAR(opline->op1.var);
if (Z_TYPE_P(var) != IS_ARRAY && Z_FE_ITER_P(var) != (uint32_t)-1) {
zend_hash_iterator_del(Z_FE_ITER_P(var));
}
zval_ptr_dtor_nogc(var);
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
ZEND_VM_HANDLER(54, ZEND_ADD_CHAR, TMP|UNUSED, CONST)
{
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *str = EX_VAR(opline->result.var);
- Added indirect method call through array variable (FR Bug #47160)
2011-06-06 21:42:05 +00:00
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
SAVE_OPLINE();
fix bug #61782 - __clone/__destruct do not match other methods when checking access controls
2012-05-13 05:12:48 +00:00
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
if (OP1_TYPE == IS_UNUSED) {
/* Initialize for erealloc in add_char_to_string */
Refactored ZVAL flags usage to simplify various checks (e.g. Z_REFCOUNTED(), candidate for GC, etc)
2014-04-03 11:26:23 +00:00
ZVAL_EMPTY_STRING(str);
Fixed bug #33318 (throw 1; results in Invalid opcode 108/1/8)
2005-06-16 14:20:00 +00:00
}
Speed-up of ZEND_DO_FCALL and ZEND_INIT_FCALL_BY_NAME by lowercasing and calculating hash values at compile time.
2007-11-22 09:02:55 +00:00
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
add_char_to_string(str, str, EX_CONSTANT(opline->op2));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
/* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
/*CHECK_EXCEPTION();*/
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(55, ZEND_ADD_STRING, TMP|UNUSED, CONST)
Speed-up of ZEND_DO_FCALL and ZEND_INIT_FCALL_BY_NAME by lowercasing and calculating hash values at compile time.
2007-11-22 09:02:55 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *str = EX_VAR(opline->result.var);
ws
2010-04-27 12:23:29 +00:00
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
SAVE_OPLINE();
ws
2010-04-27 12:23:29 +00:00
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
if (OP1_TYPE == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
Refactored ZVAL flags usage to simplify various checks (e.g. Z_REFCOUNTED(), candidate for GC, etc)
2014-04-03 11:26:23 +00:00
ZVAL_EMPTY_STRING(str);
Speed-up of ZEND_DO_FCALL and ZEND_INIT_FCALL_BY_NAME by lowercasing and calculating hash values at compile time.
2007-11-22 09:02:55 +00:00
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
add_string_to_string(str, str, EX_CONSTANT(opline->op2));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
/*CHECK_EXCEPTION();*/
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(56, ZEND_ADD_VAR, TMP|UNUSED, TMPVAR|CV)
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
. Added support for using static HEREDOCs to initialize static variables and class members or constants. (Matt) . Improved syntax highlighting and consistency for variables in double-quoted strings and literal text in HEREDOCs and backticks. (Matt) . Optimized interpolated strings to use one less opcode. (Matt)
2008-07-26 15:30:28 +00:00
zend_free_op free_op2;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *str = EX_VAR(opline->result.var);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *var;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zval var_copy;
Improved compilation of heredocs and interpolated strings. (Matt, Dmitry)
2007-05-18 13:12:05 +00:00
int use_copy = 0;
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
var = GET_OP2_ZVAL_PTR(BP_VAR_R);
Support trivial finally in generators (no yield, no return) The finally clause is now properly run when an exception is thrown in the try-block. It is not yet run on `return` and also not run when the generator is claused within a try block. I'll add those two things as soon as laruence refactored the finally code.
2012-08-13 15:17:18 +00:00
. Added support for using static HEREDOCs to initialize static variables and class members or constants. (Matt) . Improved syntax highlighting and consistency for variables in double-quoted strings and literal text in HEREDOCs and backticks. (Matt) . Optimized interpolated strings to use one less opcode. (Matt)
2008-07-26 15:30:28 +00:00
if (OP1_TYPE == IS_UNUSED) {
/* Initialize for erealloc in add_string_to_string */
Refactored ZVAL flags usage to simplify various checks (e.g. Z_REFCOUNTED(), candidate for GC, etc)
2014-04-03 11:26:23 +00:00
ZVAL_EMPTY_STRING(str);
Support trivial finally in generators (no yield, no return) The finally clause is now properly run when an exception is thrown in the try-block. It is not yet run on `return` and also not run when the generator is claused within a try block. I'll add those two things as soon as laruence refactored the finally code.
2012-08-13 15:17:18 +00:00
}
Improved compilation of heredocs and interpolated strings. (Matt, Dmitry)
2007-05-18 13:12:05 +00:00
if (Z_TYPE_P(var) != IS_STRING) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
use_copy = zend_make_printable_zval(var, &var_copy);
Improved compilation of heredocs and interpolated strings. (Matt, Dmitry)
2007-05-18 13:12:05 +00:00
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
if (use_copy) {
var = &var_copy;
Improved compilation of heredocs and interpolated strings. (Matt, Dmitry)
2007-05-18 13:12:05 +00:00
}
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
}
. Added support for using static HEREDOCs to initialize static variables and class members or constants. (Matt) . Improved syntax highlighting and consistency for variables in double-quoted strings and literal text in HEREDOCs and backticks. (Matt) . Optimized interpolated strings to use one less opcode. (Matt)
2008-07-26 15:30:28 +00:00
add_string_to_string(str, str, var);
fix UMR when variable name is an object and __toString is used # zend_call_function checks IS_REF on This
2011-03-16 05:25:02 +00:00
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (use_copy) {
Use specialized destructors when types of zvals are known.
2014-11-24 22:22:59 +00:00
zend_string_release(Z_STR_P(var));
Fixed bug #54367 (Use of closure causes problem in ArrayAccess).
2011-04-20 12:59:18 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* original comment, possibly problematic:
* FREE_OP is missing intentionally here - we're always working on the same temporary variable
* (Zeev): I don't think it's problematic, we only use variables
* which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
* string offsets or overloaded objects
*/
FREE_OP2();
Fixed bug #54367 (Use of closure causes problem in ArrayAccess).
2011-04-20 12:59:18 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
fix UMR when variable name is an object and __toString is used # zend_call_function checks IS_REF on This
2011-03-16 05:25:02 +00:00
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Add functions declarations, use tabs
2012-08-14 00:59:40 +00:00
if (EG(exception)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_exception_save();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (OP2_TYPE == IS_UNUSED) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
Improved specialization (IS_CONST can't be IS_OBJECT)
2009-04-08 13:19:34 +00:00
} else {
zend_free_op free_op2;
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
zval *class_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
ZEND_VM_C_LABEL(try_class_name):
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
if (OP2_TYPE == IS_CONST) {
Use local variables instead of opline operands to access cache_slots
2014-04-17 12:10:16 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) {
Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), EX_CONSTANT(opline->op2) + 1, opline->extended_value);
Use local variables instead of opline operands to access cache_slots
2014-04-17 12:10:16 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var)));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
} else if (Z_TYPE_P(class_name) == IS_OBJECT) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
Improved specialization (IS_CONST can't be IS_OBJECT)
2009-04-08 13:19:34 +00:00
} else if (Z_TYPE_P(class_name) == IS_STRING) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value);
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
} else if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
class_name = Z_REFVAL_P(class_name);
ZEND_VM_C_GOTO(try_class_name);
Improved specialization (IS_CONST can't be IS_OBJECT)
2009-04-08 13:19:34 +00:00
} else {
Exceptions triggered by undefined variable should be handled before FATAL error this is a enhancement of the fix for bug #64135
2013-02-16 14:22:22 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Class name must be a valid object or a string");
Improved specialization (IS_CONST can't be IS_OBJECT)
2009-04-08 13:19:34 +00:00
}
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
Improved specialization (IS_CONST can't be IS_OBJECT)
2009-04-08 13:19:34 +00:00
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
Improved specialization (IS_CONST can't be IS_OBJECT)
2009-04-08 13:19:34 +00:00
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMPVAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zval *function_name;
zend_free_op free_op1, free_op2;
Fixed support for references
2014-02-28 11:58:11 +00:00
zval *object;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zend_function *fbc;
zend_class_entry *called_scope;
zend_object *obj;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (OP2_TYPE != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
Fixed bug #69124 (method name could not be used when by ref)
2015-02-26 13:21:48 +00:00
do {
if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
function_name = Z_REFVAL_P(function_name);
if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
break;
}
}
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Method name must be a string");
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
FREE_OP2();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
FREE_UNFETCHED_OP1();
HANDLE_EXCEPTION();
Fixed bug #69124 (method name could not be used when by ref)
2015-02-26 13:21:48 +00:00
} while (0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Handle ZEND_EXT_FCALL_END, skipping if necessary Verified with running tests with new "-e" run-tests arg: $ make test TESTS=Zend/tests/*-on-non-objects-*phpt TEST_PHP_ARGS=-e # Tests passed : 11 (100.0%) $ make test TESTS=Zend/tests/*-on-non-objects-*phpt # Tests passed : 11 (100.0%) Before, this would cause a SEGV. Thanks @nikic for raising this concern
2014-07-06 12:48:42 +00:00
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
object = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
if (OP1_TYPE != IS_UNUSED) {
ZVAL_DEREF(object);
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
Errors converted to exceptions are not "recoverable" anymore.
2015-03-10 07:31:55 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
FREE_OP2();
FREE_OP1();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
HANDLE_EXCEPTION();
Handle ZEND_EXT_FCALL_END, skipping if necessary Verified with running tests with new "-e" run-tests arg: $ make test TESTS=Zend/tests/*-on-non-objects-*phpt TEST_PHP_ARGS=-e # Tests passed : 11 (100.0%) $ make test TESTS=Zend/tests/*-on-non-objects-*phpt # Tests passed : 11 (100.0%) Before, this would cause a SEGV. Thanks @nikic for raising this concern
2014-07-06 12:48:42 +00:00
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
}
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
obj = Z_OBJ_P(object);
Remove zend_get_class_entry function
2014-10-09 12:17:30 +00:00
called_scope = obj->ce;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (OP2_TYPE != IS_CONST ||
Reorder conditions to make "fast paths" shorter
2015-01-13 12:31:42 +00:00
UNEXPECTED((fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope)) == NULL)) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zend_object *orig_obj = obj;
if (UNEXPECTED(obj->handlers->get_method == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Object does not support method calls");
FREE_OP2();
FREE_OP1();
HANDLE_EXCEPTION();
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
/* First, locate the function. */
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL));
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (UNEXPECTED(fbc == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name));
FREE_OP2();
FREE_OP1();
HANDLE_EXCEPTION();
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
if (OP2_TYPE == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
EXPECTED(obj == orig_obj)) {
CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
}
}
Help to CPU branch predictor
2014-10-09 19:58:41 +00:00
if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
obj = NULL;
fix UMR when variable name is an object and __toString is used # zend_call_function checks IS_REF on This
2011-03-16 05:25:02 +00:00
} else {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
GC_REFCOUNT(obj)++; /* For $this pointer */
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
}
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
fbc, opline->extended_value, called_scope, obj, EX(call));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP2();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
FREE_OP1();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zval *function_name;
zend_class_entry *ce;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zend_object *object;
zend_function *fbc;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
ws
2007-10-03 06:49:15 +00:00
Clenaup deprecated namespace code
2009-03-10 10:01:44 +00:00
if (OP1_TYPE == IS_CONST) {
ws
2007-10-03 06:49:15 +00:00
/* no function found. try a static method in class */
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) {
ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
Added support for Late Static Binding. (Dmitry, Etienne Kneuss)
2007-09-29 07:28:34 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT);
Fixed bug #65254 (Exception not catchable when exception thrown in autoload with a namespace).
2013-07-14 03:47:06 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
if (UNEXPECTED(ce == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1)));
HANDLE_EXCEPTION();
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce);
Added support for Late Static Binding. (Dmitry, Etienne Kneuss)
2007-09-29 07:28:34 +00:00
}
Namespaces
2007-09-28 19:52:53 +00:00
} else {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ce = Z_CE_P(EX_VAR(opline->op1.var));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
if (OP1_TYPE == IS_CONST &&
OP2_TYPE == IS_CONST &&
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) {
fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else if (OP1_TYPE != IS_CONST &&
OP2_TYPE == IS_CONST &&
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
(fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) {
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
/* do nothing */
} else if (OP2_TYPE != IS_UNUSED) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op2;
Added support for Late Static Binding. (Dmitry, Etienne Kneuss)
2007-09-29 07:28:34 +00:00
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
if (OP2_TYPE != IS_CONST) {
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
Exceptions triggered by undefined variable should be handled before FATAL error this is a enhancement of the fix for bug #64135
2013-02-16 14:22:22 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Function name must be a string");
FREE_OP2();
HANDLE_EXCEPTION();
- Fixed bug #45089 (__callStatic $name case sensitivity)
2008-06-03 18:11:12 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
if (ce->get_static_method) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
fbc = ce->get_static_method(ce, Z_STR_P(function_name));
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL));
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (UNEXPECTED(fbc == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
FREE_OP2();
HANDLE_EXCEPTION();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
}
if (OP2_TYPE == IS_CONST &&
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
if (OP1_TYPE == IS_CONST) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- Fixed bug #45089 (__callStatic $name case sensitivity)
2008-06-03 18:11:12 +00:00
} else {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
Added support for __callstatic() magic method (missing part). (Sara)
2007-09-29 09:34:24 +00:00
}
Additional executor specialization
2008-01-23 17:55:55 +00:00
if (OP2_TYPE != IS_CONST) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP2();
}
} else {
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (UNEXPECTED(ce->constructor == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot call constructor");
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Remove zend_get_class_entry function
2014-10-09 12:17:30 +00:00
if (Z_OBJ(EX(This)) && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
HANDLE_EXCEPTION();
- MFH Fixed Bug #38064 ignored constructor visibility
2006-08-07 23:24:33 +00:00
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
fbc = ce->constructor;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
object = NULL;
if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (Z_OBJ(EX(This))) {
object = Z_OBJ(EX(This));
Use data stored in current call frame instead of EG() if possible
2014-07-09 13:07:41 +00:00
GC_REFCOUNT(object)++;
Moved checks and error reporting related to static methods from DO_FCALL inti INTI_FCALL* opcodes that may really deal with static methods. (In some rare cases it may lead to different order of warning messages).
2014-10-04 10:55:44 +00:00
}
Revert "Remove static calls from incompatible $this context" This reverts commit dc9991b167533c7ee13ff96da6048988e6e31bc2.
2015-01-19 14:12:51 +00:00
if (!object ||
!instanceof_function(object->ce, ce)) {
/* We are calling method of the other (incompatible) class,
but passing $this. This is done for compatibility with php-4. */
Moved checks and error reporting related to static methods from DO_FCALL inti INTI_FCALL* opcodes that may really deal with static methods. (In some rare cases it may lead to different order of warning messages).
2014-10-04 10:55:44 +00:00
if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
Revert "Remove static calls from incompatible $this context" This reverts commit dc9991b167533c7ee13ff96da6048988e6e31bc2.
2015-01-19 14:12:51 +00:00
zend_error(
object ? E_DEPRECATED : E_STRICT,
"Non-static method %s::%s() should not be called statically%s",
fbc->common.scope->name->val, fbc->common.function_name->val,
object ? ", assuming $this from incompatible context" : "");
Moved checks and error reporting related to static methods from DO_FCALL inti INTI_FCALL* opcodes that may really deal with static methods. (In some rare cases it may lead to different order of warning messages).
2014-10-04 10:55:44 +00:00
} else {
Revert "Remove static calls from incompatible $this context" This reverts commit dc9991b167533c7ee13ff96da6048988e6e31bc2.
2015-01-19 14:12:51 +00:00
/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(
E_EXCEPTION | E_ERROR,
Revert "Remove static calls from incompatible $this context" This reverts commit dc9991b167533c7ee13ff96da6048988e6e31bc2.
2015-01-19 14:12:51 +00:00
"Non-static method %s::%s() cannot be called statically%s",
fbc->common.scope->name->val, fbc->common.function_name->val,
object ? ", assuming $this from incompatible context" : "");
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
if (OP1_TYPE != IS_CONST) {
/* previous opcode is ZEND_FETCH_CLASS */
if ((opline-1)->extended_value == ZEND_FETCH_CLASS_PARENT || (opline-1)->extended_value == ZEND_FETCH_CLASS_SELF) {
Removed EG(called_scope) and use corresponding value from EG(current_execute_data)
2014-07-02 22:34:43 +00:00
ce = EX(called_scope);
Refactored data structures to keep zend_object* instead of a whole zval in some places
2014-03-27 22:11:22 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
fbc, opline->extended_value, ce, object, EX(call));
trailing whitespace removal
2015-01-03 09:22:58 +00:00
Partial fix that allows internal constructors to set $this to null. The address of $this passed to drectly called internal constructor in execute_data->return_value. Internal constructors should use ZEND_CTOR_MAKE_NULL() macro (insted of previous ZEND_NULL(EG(This))) to do the work. This patch doesn't fix the problem for indirectly called constructors. e.g. parant::__construct().
2014-07-09 07:57:42 +00:00
if (OP2_TYPE == IS_UNUSED) {
EX(call)->return_value = NULL;
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zend_function *fbc;
zval *function_name, *func;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))))) {
fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
} else {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
function_name = (zval*)(EX_CONSTANT(opline->op2)+1);
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(EX_CONSTANT(opline->op2)));
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
fbc = Z_FUNC_P(func);
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
}
EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
fbc, opline->extended_value, NULL, NULL, EX(call));
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
/*CHECK_EXCEPTION();*/
ZEND_VM_NEXT_OPCODE();
}
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
ZEND_VM_HANDLER(128, ZEND_INIT_DYNAMIC_CALL, ANY, CONST|TMPVAR|CV)
{
USE_OPLINE
zend_function *fbc;
zval *function_name, *func;
zend_string *lcname;
zend_free_op free_op2;
zend_class_entry *called_scope;
zend_object *object;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
SAVE_OPLINE();
function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
ZEND_VM_C_LABEL(try_function_name):
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
if (OP2_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
if (Z_STRVAL_P(function_name)[0] == '\\') {
lcname = zend_string_alloc(Z_STRLEN_P(function_name) - 1, 0);
zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1);
} else {
lcname = zend_string_tolower(Z_STR_P(function_name));
}
if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name));
Added new API function 'zend_string* zend_string_tolower(zend_string*)'. It simplifies code and avoids unnecessary allocation and copying if string is already in lower case.
2014-12-24 12:04:51 +00:00
zend_string_release(lcname);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
FREE_OP2();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
HANDLE_EXCEPTION();
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
}
zend_string_release(lcname);
FREE_OP2();
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
fbc = Z_FUNC_P(func);
called_scope = NULL;
object = NULL;
} else if (OP2_TYPE != IS_CONST &&
EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
Z_OBJ_HANDLER_P(function_name, get_closure) &&
Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &called_scope, &fbc, &object) == SUCCESS) {
if (object) {
GC_REFCOUNT(object)++;
}
More accurate reference counting on closures
2015-03-10 20:04:41 +00:00
if (fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
/* Delay closure destruction until its invocation */
More accurate reference counting on closures
2015-03-10 20:04:41 +00:00
ZEND_ASSERT(GC_TYPE(fbc->common.prototype) == IS_OBJECT);
GC_REFCOUNT(fbc->common.prototype)++;
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
}
More accurate reference counting on closures
2015-03-10 20:04:41 +00:00
FREE_OP2();
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
} else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
zval *obj;
zval *method;
obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0);
method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
if (!obj || !method) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Array callback has to contain indices 0 and 1");
FREE_OP2();
HANDLE_EXCEPTION();
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
}
Optimized function call helper
2008-04-21 10:14:20 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
ZVAL_DEREF(obj);
if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "First array member is not a valid class name or object");
FREE_OP2();
HANDLE_EXCEPTION();
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
ZVAL_DEREF(method);
if (Z_TYPE_P(method) != IS_STRING) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Second array member is not a valid method");
FREE_OP2();
HANDLE_EXCEPTION();
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
}
Optimized function call helper
2008-04-21 10:14:20 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
if (Z_TYPE_P(obj) == IS_STRING) {
object = NULL;
called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0);
if (UNEXPECTED(called_scope == NULL)) {
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
if (called_scope->get_static_method) {
fbc = called_scope->get_static_method(called_scope, Z_STR_P(method));
} else {
fbc = zend_std_get_static_method(called_scope, Z_STR_P(method), NULL);
Lazy EG(active_symbol_table) initialization
2008-04-29 08:15:20 +00:00
}
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
if (UNEXPECTED(fbc == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to undefined method %s::%s()", called_scope->name->val, Z_STRVAL_P(method));
FREE_OP2();
HANDLE_EXCEPTION();
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
}
if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
zend_error(E_STRICT,
Moved checks and error reporting related to static methods from DO_FCALL inti INTI_FCALL* opcodes that may really deal with static methods. (In some rare cases it may lead to different order of warning messages).
2014-10-04 10:55:44 +00:00
"Non-static method %s::%s() should not be called statically",
fbc->common.scope->name->val, fbc->common.function_name->val);
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
} else {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(
E_EXCEPTION | E_ERROR,
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
"Non-static method %s::%s() cannot be called statically",
fbc->common.scope->name->val, fbc->common.function_name->val);
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
FREE_OP2();
HANDLE_EXCEPTION();
Optimized function call helper
2008-04-21 10:14:20 +00:00
}
Fixed bug #30162 (Catching exception in constructor couses lose of $this)
2005-05-04 08:45:46 +00:00
}
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
} else {
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
called_scope = Z_OBJCE_P(obj);
object = Z_OBJ_P(obj);
fbc = Z_OBJ_HT_P(obj)->get_method(&object, Z_STR_P(method), NULL);
if (UNEXPECTED(fbc == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to undefined method %s::%s()", object->ce->name->val, Z_STRVAL_P(method));
FREE_OP2();
Exceptions triggered by undefined variable should be handled before FATAL error this is a enhancement of the fix for bug #64135
2013-02-16 14:22:22 +00:00
HANDLE_EXCEPTION();
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
if ((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
object = NULL;
} else {
GC_REFCOUNT(object)++; /* For $this pointer */
}
}
FREE_OP2();
} else if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(function_name) == IS_REFERENCE) {
function_name = Z_REFVAL_P(function_name);
ZEND_VM_C_GOTO(try_function_name);
} else {
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Function name must be a string");
FREE_OP2();
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
fbc, opline->extended_value, called_scope, object, EX(call));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV)
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
{
USE_OPLINE
zend_free_op free_op2;
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
zval *function_name;
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
zend_fcall_info_cache fcc;
char *error = NULL;
zend_function *func;
zend_class_entry *called_scope;
zend_object *object;
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
SAVE_OPLINE();
function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
if (error) {
efree(error);
}
func = fcc.function_handler;
if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
/* Delay closure destruction until its invocation */
More accurate reference counting on closures
2015-03-10 20:04:41 +00:00
if (OP2_TYPE & (IS_VAR|IS_CV)) {
ZVAL_DEREF(function_name);
}
ZEND_ASSERT(GC_TYPE(func->common.prototype) == IS_OBJECT);
GC_REFCOUNT(func->common.prototype)++;
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
}
called_scope = fcc.called_scope;
object = fcc.object;
if (object) {
GC_REFCOUNT(object)++; /* For $this pointer */
Moved checks and error reporting related to static methods from DO_FCALL inti INTI_FCALL* opcodes that may really deal with static methods. (In some rare cases it may lead to different order of warning messages).
2014-10-04 10:55:44 +00:00
} else if (func->common.scope &&
!(func->common.fn_flags & ZEND_ACC_STATIC)) {
if (func->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
zend_error(E_STRICT,
"Non-static method %s::%s() should not be called statically",
func->common.scope->name->val, func->common.function_name->val);
} else {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(
E_EXCEPTION | E_ERROR,
Moved checks and error reporting related to static methods from DO_FCALL inti INTI_FCALL* opcodes that may really deal with static methods. (In some rare cases it may lead to different order of warning messages).
2014-10-04 10:55:44 +00:00
"Non-static method %s::%s() cannot be called statically",
func->common.scope->name->val, func->common.function_name->val);
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
FREE_OP2();
HANDLE_EXCEPTION();
Moved checks and error reporting related to static methods from DO_FCALL inti INTI_FCALL* opcodes that may really deal with static methods. (In some rare cases it may lead to different order of warning messages).
2014-10-04 10:55:44 +00:00
}
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
}
} else {
Refactor as to not use call info, but add the flag to the op_array.
2015-03-19 17:30:11 +00:00
zend_internal_type_error(EX_USES_STRICT_TYPES(), "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error);
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
efree(error);
func = (zend_function*)&zend_pass_function;
called_scope = NULL;
object = NULL;
}
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
func, opline->extended_value, called_scope, object, EX(call));
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
FREE_OP2();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Optimized function call helper
2008-04-21 10:14:20 +00:00
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST)
{
USE_OPLINE
Moved zend_literal->cache_slot right into zval. It should be accessed using Z_CACHE_SLOT() macro. zend_literal structure is removed. API functions that accepted pointer to zend_literal now accept pointer to zval or cache_slot directly. Calls of such functiond that now accept cache_slot need to be changed to pass -1 instead of NULL.
2014-04-17 11:40:45 +00:00
zval *func_name;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *func;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zend_function *fbc;
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
func_name = EX_CONSTANT(opline->op2) + 1;
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) {
fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
Moved zend_literal->cache_slot right into zval. It should be accessed using Z_CACHE_SLOT() macro. zend_literal structure is removed. API functions that accepted pointer to zend_literal now accept pointer to zval or cache_slot directly. Calls of such functiond that now accept cache_slot need to be changed to pass -1 instead of NULL.
2014-04-17 11:40:45 +00:00
} else if ((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL) {
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
func_name++;
Moved zend_literal->cache_slot right into zval. It should be accessed using Z_CACHE_SLOT() macro. zend_literal structure is removed. API functions that accepted pointer to zend_literal now accept pointer to zval or cache_slot directly. Calls of such functiond that now accept cache_slot need to be changed to pass -1 instead of NULL.
2014-04-17 11:40:45 +00:00
if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL)) {
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
SAVE_OPLINE();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(EX_CONSTANT(opline->op2)));
HANDLE_EXCEPTION();
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
} else {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
fbc = Z_FUNC_P(func);
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
} else {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
fbc = Z_FUNC_P(func);
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
fbc, opline->extended_value, NULL, NULL, EX(call));
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_HANDLER(61, ZEND_INIT_FCALL, ANY, CONST)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zend_free_op free_op2;
zval *fname = GET_OP2_ZVAL_PTR(BP_VAR_R);
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *func;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zend_function *fbc;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Use local variables instead of opline operands to access cache_slots
2014-04-17 12:10:16 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(fname))) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
fbc = CACHED_PTR(Z_CACHE_SLOT_P(fname));
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
} else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(fname))) == NULL)) {
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(fname));
HANDLE_EXCEPTION();
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
fbc = Z_FUNC_P(func);
CACHE_PTR(Z_CACHE_SLOT_P(fname), fbc);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
EX(call) = zend_vm_stack_push_call_frame_ex(
opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
Merge remote-tracking branch 'origin/master' into native-tls * origin/master: Optimize argument passing handlers: Fix pcre non-FAST_ZPP build Conflicts: Zend/zend_compile.c Zend/zend_execute.h Zend/zend_vm_def.h Zend/zend_vm_execute.h ext/pcre/php_pcre.c
2014-12-16 16:13:47 +00:00
fbc, opline->extended_value, NULL, NULL, EX(call));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
}
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
ZEND_VM_HANDLER(129, ZEND_DO_ICALL, ANY, ANY)
{
USE_OPLINE
zend_execute_data *call = EX(call);
zend_function *fbc = call->func;
zval *ret;
SAVE_OPLINE();
EX(call) = call->prev_execute_data;
call->called_scope = EX(called_scope);
Z_OBJ(call->This) = Z_OBJ(EX(This));
call->prev_execute_data = execute_data;
EG(current_execute_data) = call;
ret = EX_VAR(opline->result.var);
ZVAL_NULL(ret);
Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
fbc->internal_function.handler(call, ret);
Introduce ZEND_ASSUME() macro to help optimizing code. Reuse ZEND_ASSERT() conditions for optimization.
2015-03-24 09:21:06 +00:00
#if ZEND_DEBUG
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
ZEND_ASSERT(
!call->func ||
!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
zend_verify_internal_return_type(call->func, EX_VAR(opline->result.var)));
Introduce ZEND_ASSUME() macro to help optimizing code. Reuse ZEND_ASSERT() conditions for optimization.
2015-03-24 09:21:06 +00:00
#endif
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
EG(current_execute_data) = call->prev_execute_data;
zend_vm_stack_free_args(call);
zend_vm_stack_free_call_frame(call);
if (!RETURN_VALUE_USED(opline)) {
zval_ptr_dtor(EX_VAR(opline->result.var));
}
if (UNEXPECTED(EG(exception) != NULL)) {
zend_throw_exception_internal(NULL);
if (RETURN_VALUE_USED(opline)) {
zval_ptr_dtor(EX_VAR(opline->result.var));
}
HANDLE_EXCEPTION();
}
improved timeout handling on windows
2015-03-16 16:48:29 +00:00
ZEND_VM_INTERRUPT_CHECK();
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(130, ZEND_DO_UCALL, ANY, ANY)
{
USE_OPLINE
zend_execute_data *call = EX(call);
zend_function *fbc = call->func;
zval *ret;
SAVE_OPLINE();
EX(call) = call->prev_execute_data;
EG(scope) = NULL;
ret = NULL;
call->symbol_table = NULL;
if (RETURN_VALUE_USED(opline)) {
ret = EX_VAR(opline->result.var);
ZVAL_NULL(ret);
Z_VAR_FLAGS_P(ret) = 0;
}
call->prev_execute_data = execute_data;
i_init_func_execute_data(call, &fbc->op_array, ret, 0);
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
ZEND_VM_ENTER();
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
}
Optimized function call helper
2008-04-21 10:14:20 +00:00
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
ZEND_VM_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY)
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
{
USE_OPLINE
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
zend_execute_data *call = EX(call);
zend_function *fbc = call->func;
zval *ret;
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
SAVE_OPLINE();
EX(call) = call->prev_execute_data;
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
EG(scope) = NULL;
if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_GENERATOR) != 0)) {
if (RETURN_VALUE_USED(opline)) {
zend_generator_create_zval(call, &fbc->op_array, EX_VAR(opline->result.var));
} else {
zend_vm_stack_free_args(call);
}
zend_vm_stack_free_call_frame(call);
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
} else {
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
ret = NULL;
call->symbol_table = NULL;
if (RETURN_VALUE_USED(opline)) {
ret = EX_VAR(opline->result.var);
ZVAL_NULL(ret);
Z_VAR_FLAGS_P(ret) = 0;
}
call->prev_execute_data = execute_data;
i_init_func_execute_data(call, &fbc->op_array, ret, 0);
ZEND_VM_ENTER();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
EG(scope) = EX(func)->op_array.scope;
Fixed bug that jmp in try block jmp over finally block Refactor the implemention, make codes clear
2012-08-22 10:32:03 +00:00
} else {
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
fbc->common.scope ? fbc->common.scope->name->val : "",
fbc->common.scope ? "::" : "",
fbc->common.function_name->val);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
call->called_scope = EX(called_scope);
Z_OBJ(call->This) = Z_OBJ(EX(This));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
call->prev_execute_data = execute_data;
EG(current_execute_data) = call;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
uint32_t i;
uint32_t num_args = ZEND_CALL_NUM_ARGS(call);
zval *p = ZEND_CALL_ARG(call, 1);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
for (i = 0; i < num_args; ++i) {
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
zend_verify_internal_arg_type(fbc, i + 1, p);
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
p++;
}
if (UNEXPECTED(EG(exception) != NULL)) {
EG(current_execute_data) = call->prev_execute_data;
zend_vm_stack_free_args(call);
zend_vm_stack_free_call_frame(call);
zend_throw_exception_internal(NULL);
HANDLE_EXCEPTION();
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
ret = EX_VAR(opline->result.var);
ZVAL_NULL(ret);
Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
fbc->internal_function.handler(call, ret);
Introduce ZEND_ASSUME() macro to help optimizing code. Reuse ZEND_ASSERT() conditions for optimization.
2015-03-24 09:21:06 +00:00
#if ZEND_DEBUG
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
ZEND_ASSERT(
!call->func ||
!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
zend_verify_internal_return_type(call->func, EX_VAR(opline->result.var)));
Introduce ZEND_ASSUME() macro to help optimizing code. Reuse ZEND_ASSERT() conditions for optimization.
2015-03-24 09:21:06 +00:00
#endif
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
EG(current_execute_data) = call->prev_execute_data;
zend_vm_stack_free_args(call);
zend_vm_stack_free_call_frame(call);
if (!RETURN_VALUE_USED(opline)) {
zval_ptr_dtor(EX_VAR(opline->result.var));
}
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
zend_throw_exception_internal(NULL);
if (RETURN_VALUE_USED(opline)) {
zval_ptr_dtor(EX_VAR(opline->result.var));
}
HANDLE_EXCEPTION();
}
improved timeout handling on windows
2015-03-16 16:48:29 +00:00
ZEND_VM_INTERRUPT_CHECK();
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY)
{
USE_OPLINE
zend_execute_data *call = EX(call);
zend_function *fbc = call->func;
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
zend_object *object = Z_OBJ(call->This);
Cleanup
2014-12-29 10:38:36 +00:00
zval *ret;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
SAVE_OPLINE();
Removed zend_execute_data->prev_nested_call. Reuse prev_execute_data instead.
2014-10-01 06:46:13 +00:00
EX(call) = call->prev_execute_data;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) {
if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name->val, fbc->common.function_name->val);
HANDLE_EXCEPTION();
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
fbc->common.scope ? fbc->common.scope->name->val : "",
fbc->common.scope ? "::" : "",
fbc->common.function_name->val);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
}
}
LOAD_OPLINE();
Reored conditions
2014-12-29 11:20:52 +00:00
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
EG(scope) = fbc->common.scope;
if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_GENERATOR) != 0)) {
if (RETURN_VALUE_USED(opline)) {
zend_generator_create_zval(call, &fbc->op_array, EX_VAR(opline->result.var));
} else {
zend_vm_stack_free_args(call);
}
trailing whitespace removal
2015-01-03 09:22:58 +00:00
Reored conditions
2014-12-29 11:20:52 +00:00
zend_vm_stack_free_call_frame(call);
} else {
ret = NULL;
call->symbol_table = NULL;
if (RETURN_VALUE_USED(opline)) {
ret = EX_VAR(opline->result.var);
ZVAL_NULL(ret);
Z_VAR_FLAGS_P(ret) = 0;
}
call->prev_execute_data = execute_data;
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
i_init_func_execute_data(call, &fbc->op_array, ret, 1);
Reored conditions
2014-12-29 11:20:52 +00:00
if (EXPECTED(zend_execute_ex == execute_ex)) {
ZEND_VM_ENTER();
} else {
ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
zend_execute_ex(call);
}
}
} else if (EXPECTED(fbc->type < ZEND_USER_FUNCTION)) {
Revert "Removed useless local variable" This reverts commit 44ae32ad55b9ceee9eb980edefcc62df6cff3eef. It doesn't work properly. We can't access call->scope after free.
2014-12-15 22:44:10 +00:00
int should_change_scope = 0;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (fbc->common.scope) {
Revert "Removed useless local variable" This reverts commit 44ae32ad55b9ceee9eb980edefcc62df6cff3eef. It doesn't work properly. We can't access call->scope after free.
2014-12-15 22:44:10 +00:00
should_change_scope = 1;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
/* TODO: we don't set scope if we call an object method ??? */
/* See: ext/pdo_sqlite/tests/pdo_fetch_func_001.phpt */
#if 1
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
EG(scope) = object ? NULL : fbc->common.scope;
trailing whitespace removal
2015-01-03 09:22:58 +00:00
#else
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
EG(scope) = fbc->common.scope;
#endif
trailing whitespace removal
2015-01-03 09:22:58 +00:00
} else {
Removed EG(called_scope) and use corresponding value from EG(current_execute_data)
2014-07-02 22:34:43 +00:00
call->called_scope = EX(called_scope);
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
Z_OBJ(call->This) = Z_OBJ(EX(This));
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
Use values from current_execute_data instead of globals where possible
2014-07-04 13:03:44 +00:00
call->prev_execute_data = execute_data;
Uinified call frame handling for user and internal functions. Now EG(current_execute_data) always point to the call frame of the currently executed function.
2014-07-02 18:01:25 +00:00
EG(current_execute_data) = call;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
master renames phase 2
2014-08-25 17:28:33 +00:00
uint32_t i;
Removed useless checks
2014-12-22 16:04:29 +00:00
uint32_t num_args = ZEND_CALL_NUM_ARGS(call);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zval *p = ZEND_CALL_ARG(call, 1);
Removed useless checks
2014-12-22 16:04:29 +00:00
for (i = 0; i < num_args; ++i) {
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
zend_verify_internal_arg_type(fbc, i + 1, p);
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
EG(current_execute_data) = call->prev_execute_data;
zend_vm_stack_free_args(call);
zend_vm_stack_free_call_frame(call);
if (RETURN_VALUE_USED(opline)) {
ZVAL_UNDEF(EX_VAR(opline->result.var));
}
if (UNEXPECTED(should_change_scope)) {
ZEND_VM_C_GOTO(fcall_end_change_scope);
} else {
ZEND_VM_C_GOTO(fcall_end);
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
p++;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
}
ret = EX_VAR(opline->result.var);
ZVAL_NULL(ret);
Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
if (!zend_execute_internal) {
/* saves one function call if zend_execute_internal is not used */
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
fbc->internal_function.handler(call, ret);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_execute_internal(call, ret);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
Fixed bug #69025 (Invalid read of size 4 when calling __callStatic)
2015-02-11 14:41:21 +00:00
Introduce ZEND_ASSUME() macro to help optimizing code. Reuse ZEND_ASSERT() conditions for optimization.
2015-03-24 09:21:06 +00:00
#if ZEND_DEBUG
Fixed bug #69025 (Invalid read of size 4 when calling __callStatic)
2015-02-11 14:41:21 +00:00
ZEND_ASSERT(
!call->func ||
!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
zend_verify_internal_return_type(call->func, EX_VAR(opline->result.var)));
Introduce ZEND_ASSUME() macro to help optimizing code. Reuse ZEND_ASSERT() conditions for optimization.
2015-03-24 09:21:06 +00:00
#endif
Fixed bug #69025 (Invalid read of size 4 when calling __callStatic)
2015-02-11 14:41:21 +00:00
trailing whitespace removal
2015-01-03 09:22:58 +00:00
EG(current_execute_data) = call->prev_execute_data;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_free_args(call);
zend_vm_stack_free_call_frame(call);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (!RETURN_VALUE_USED(opline)) {
Micro optimization for better register allocation
2014-12-29 11:21:16 +00:00
zval_ptr_dtor(EX_VAR(opline->result.var));
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Revert "Removed useless local variable" This reverts commit 44ae32ad55b9ceee9eb980edefcc62df6cff3eef. It doesn't work properly. We can't access call->scope after free.
2014-12-15 22:44:10 +00:00
if (UNEXPECTED(should_change_scope)) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_C_GOTO(fcall_end_change_scope);
} else {
ZEND_VM_C_GOTO(fcall_end);
}
} else { /* ZEND_OVERLOADED_FUNCTION */
EG(scope) = fbc->common.scope;
ZVAL_NULL(EX_VAR(opline->result.var));
/* Not sure what should be done here if it's a static method */
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (EXPECTED(object != NULL)) {
Use values from current_execute_data instead of globals where possible
2014-07-04 13:03:44 +00:00
call->prev_execute_data = execute_data;
Uinified call frame handling for user and internal functions. Now EG(current_execute_data) always point to the call frame of the currently executed function.
2014-07-02 18:01:25 +00:00
EG(current_execute_data) = call;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
object->handlers->call_method(fbc->common.function_name, object, call, EX_VAR(opline->result.var));
Uinified call frame handling for user and internal functions. Now EG(current_execute_data) always point to the call frame of the currently executed function.
2014-07-02 18:01:25 +00:00
EG(current_execute_data) = call->prev_execute_data;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
} else {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot call overloaded function for non-object");
Comment out for now
2015-03-11 08:54:51 +00:00
#if 0
//TODO: implement clean exit ???
Fixed memleak
2015-03-11 05:42:39 +00:00
zend_vm_stack_free_args(call);
zend_vm_stack_free_call_frame(call);
if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
zend_string_release(fbc->common.function_name);
}
efree(fbc);
Comment out for now
2015-03-11 08:54:51 +00:00
#endif
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
HANDLE_EXCEPTION();
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_free_args(call);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_free_call_frame(call);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
master renames phase 1
2014-08-25 17:24:55 +00:00
zend_string_release(fbc->common.function_name);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
efree(fbc);
if (!RETURN_VALUE_USED(opline)) {
zval_ptr_dtor(EX_VAR(opline->result.var));
} else {
//??? Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr);
//??? Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1);
Z_VAR_FLAGS_P(EX_VAR(opline->result.var)) = 0;
}
}
ZEND_VM_C_LABEL(fcall_end_change_scope):
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (object) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (UNEXPECTED(EG(exception) != NULL) && (opline->op1.num & ZEND_CALL_CTOR)) {
if (!(opline->op1.num & ZEND_CALL_CTOR_RESULT_UNUSED)) {
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
GC_REFCOUNT(object)--;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (GC_REFCOUNT(object) == 1) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_object_store_ctor_failed(object);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
}
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
OBJ_RELEASE(object);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
}
Get rid of EX(scope). In most cases we use EG(scope) anyway. EX(scope) was used to switch EG(scope) back after call, but it's possibleto use EX(func)->common.scope instead.
2014-11-28 07:21:18 +00:00
EG(scope) = EX(func)->op_array.scope;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_C_LABEL(fcall_end):
if (UNEXPECTED(EG(exception) != NULL)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_throw_exception_internal(NULL);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (RETURN_VALUE_USED(opline)) {
zval_ptr_dtor(EX_VAR(opline->result.var));
}
HANDLE_EXCEPTION();
}
improved timeout handling on windows
2015-03-16 16:48:29 +00:00
ZEND_VM_INTERRUPT_CHECK();
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_NEXT_OPCODE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00:00
ZEND_VM_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED)
{
Fixed ability to build unspecialized executor
2015-02-26 14:53:03 +00:00
#if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00:00
USE_OPLINE
Fixed unused opline warning
2015-01-31 08:50:17 +00:00
#endif
Fixed return type hint handling for constants
2015-03-20 15:36:43 +00:00
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00:00
SAVE_OPLINE();
if (OP1_TYPE == IS_UNUSED) {
zend_verify_missing_return_type(EX(func));
} else {
Prevent "undefined variable opline" errors
2015-02-02 20:07:46 +00:00
/* prevents "undefined variable opline" errors */
Fixed return type hint handling for constants
2015-03-20 15:36:43 +00:00
#if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Fix VERIFY_RETURN separation a) The SAME_FAKE_TYPE check should always occur on the dereferenced value, otherwise we'll end up separating large referenced arrays. b) For by-val return with an rc=1 reference, the SEPARATE_ZVAL wouldn't do anything. Add a ZVAL_UNREF for this case. I don't like this fix - there must be some better way to express this.
2015-03-24 09:48:16 +00:00
zval *retval_ref, *retval_ptr;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00:00
zend_free_op free_op1;
Reduce the number of times that the zval needs to be separated in return type checking to those that are necessary
2015-03-19 21:47:43 +00:00
zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00:00
Fix VERIFY_RETURN separation a) The SAME_FAKE_TYPE check should always occur on the dereferenced value, otherwise we'll end up separating large referenced arrays. b) For by-val return with an rc=1 reference, the SEPARATE_ZVAL wouldn't do anything. Add a ZVAL_UNREF for this case. I don't like this fix - there must be some better way to express this.
2015-03-24 09:48:16 +00:00
retval_ref = retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
Fixed white spaces
2015-03-20 08:10:29 +00:00
Fixed in-place modification of IS_CONST operand
2015-03-20 21:22:25 +00:00
if (OP1_TYPE == IS_CONST) {
ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
Fix VERIFY_RETURN separation a) The SAME_FAKE_TYPE check should always occur on the dereferenced value, otherwise we'll end up separating large referenced arrays. b) For by-val return with an rc=1 reference, the SEPARATE_ZVAL wouldn't do anything. Add a ZVAL_UNREF for this case. I don't like this fix - there must be some better way to express this.
2015-03-24 09:48:16 +00:00
retval_ref = retval_ptr = EX_VAR(opline->result.var);
} else if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
ZVAL_DEREF(retval_ptr);
Fixed in-place modification of IS_CONST operand
2015-03-20 21:22:25 +00:00
}
Fixed white spaces
2015-03-20 08:10:29 +00:00
if (UNEXPECTED(!ret_info->class_name
&& ret_info->type_hint != IS_CALLABLE
Reduce the number of times that the zval needs to be separated in return type checking to those that are necessary
2015-03-19 21:47:43 +00:00
&& !ZEND_SAME_FAKE_TYPE(ret_info->type_hint, Z_TYPE_P(retval_ptr)))) {
/* A cast or an error will happen, so separate the zval to prevent overwriting it */
Fixed white spaces
2015-03-20 08:10:29 +00:00
Fixed return type hint handling for constants
2015-03-20 15:36:43 +00:00
if (EXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) == 0)) {
Reduce the number of times that the zval needs to be separated in return type checking to those that are necessary
2015-03-19 21:47:43 +00:00
/* Does not return by reference */
Fix VERIFY_RETURN separation a) The SAME_FAKE_TYPE check should always occur on the dereferenced value, otherwise we'll end up separating large referenced arrays. b) For by-val return with an rc=1 reference, the SEPARATE_ZVAL wouldn't do anything. Add a ZVAL_UNREF for this case. I don't like this fix - there must be some better way to express this.
2015-03-24 09:48:16 +00:00
if (retval_ref != retval_ptr && Z_REFCOUNT_P(retval_ref) == 1) {
ZVAL_UNREF(retval_ref);
} else {
SEPARATE_ZVAL(retval_ref);
}
retval_ptr = retval_ref;
Reduce the number of times that the zval needs to be separated in return type checking to those that are necessary
2015-03-19 21:47:43 +00:00
} else {
SEPARATE_ZVAL_NOREF(retval_ptr);
}
Fix return type separation with references. It now includes a check in the opcode handler and properly separates the value in both cases
2015-03-18 22:10:08 +00:00
}
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
zend_verify_return_type(EX(func), retval_ptr);
Prevent "undefined variable opline" errors
2015-02-02 20:07:46 +00:00
#endif
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00:00
}
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
ZEND_RETURN is splitted into two new instructions ZEND_RETURN and ZEND_RETURN_BY_REF
2010-04-22 11:56:45 +00:00
{
USE_OPLINE
zval *retval_ptr;
zend_free_op free_op1;
SAVE_OPLINE();
retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
if (!EX(return_value)) {
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP1();
Removed redundand code
2013-03-13 13:51:10 +00:00
} else {
trailing whitespace removal
2015-01-03 09:22:58 +00:00
if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
Fixed return of references by value
2014-03-04 13:38:19 +00:00
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
Optimized conditions order
2014-06-02 23:54:03 +00:00
if (OP1_TYPE == IS_CONST) {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
if (UNEXPECTED(Z_OPT_COPYABLE_P(EX(return_value)))) {
zval_copy_ctor_func(EX(return_value));
}
Removed redundand code
2013-03-13 13:51:10 +00:00
}
Specialization (only IS_VAR ad IS_CV operands may be references)
2014-09-22 12:17:35 +00:00
} else if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) && Z_ISREF_P(retval_ptr)) {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
ZVAL_COPY(EX(return_value), Z_REFVAL_P(retval_ptr));
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP1_IF_VAR();
ZEND_RETURN is splitted into two new instructions ZEND_RETURN and ZEND_RETURN_BY_REF
2010-04-22 11:56:45 +00:00
} else {
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
if (OP1_TYPE == IS_CV) {
Various VM optimizations
2014-04-03 22:52:53 +00:00
if (Z_OPT_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
}
ZEND_RETURN is splitted into two new instructions ZEND_RETURN and ZEND_RETURN_BY_REF
2010-04-22 11:56:45 +00:00
}
}
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
ZEND_RETURN is splitted into two new instructions ZEND_RETURN and ZEND_RETURN_BY_REF
2010-04-22 11:56:45 +00:00
}
ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zval *retval_ptr;
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_RETURN is splitted into two new instructions ZEND_RETURN and ZEND_RETURN_BY_REF
2010-04-22 11:56:45 +00:00
do {
trailing whitespace removal
2015-01-03 09:22:58 +00:00
if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR ||
Removed deprecated AI_SET_PTR()s
2013-11-27 16:30:35 +00:00
(OP1_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* Not supposed to happen, but we'll allow it */
Make references misuse emit E_NOTICE rather E_STRICT to be compatible with PHP 4.4.0
2005-07-11 18:44:37 +00:00
zend_error(E_NOTICE, "Only variable references should be returned by reference");
ZEND_RETURN is splitted into two new instructions ZEND_RETURN and ZEND_RETURN_BY_REF
2010-04-22 11:56:45 +00:00
retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
if (!EX(return_value)) {
ZEND_RETURN is splitted into two new instructions ZEND_RETURN and ZEND_RETURN_BY_REF
2010-04-22 11:56:45 +00:00
if (OP1_TYPE == IS_TMP_VAR) {
FREE_OP1();
}
} else {
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
Improved return by reference handling
2014-10-07 18:38:37 +00:00
Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF;
Optimized conditions order
2014-06-02 23:54:03 +00:00
if (OP1_TYPE != IS_TMP_VAR) {
zval_opt_copy_ctor_no_imm(EX(return_value));
Avoid copying of immutable arrays
2014-06-02 22:43:53 +00:00
}
ZEND_RETURN is splitted into two new instructions ZEND_RETURN and ZEND_RETURN_BY_REF
2010-04-22 11:56:45 +00:00
}
break;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
retval_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(retval_ptr == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot return string offsets by reference");
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Get rid of ZEND_FETCH_MAKE_REF
2014-10-22 17:45:02 +00:00
if (OP1_TYPE == IS_VAR) {
if (retval_ptr == &EG(uninitialized_zval) ||
(opline->extended_value == ZEND_RETURNS_FUNCTION &&
!(Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF))) {
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
zend_error(E_NOTICE, "Only variable references should be returned by reference");
if (EX(return_value)) {
Specialization (only IS_VAR ad IS_CV operands may be references)
2014-09-22 12:17:35 +00:00
ZVAL_NEW_REF(EX(return_value), retval_ptr);
Improved return by reference handling
2014-10-07 18:38:37 +00:00
Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF;
Specialization (only IS_VAR ad IS_CV operands may be references)
2014-09-22 12:17:35 +00:00
if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
}
break;
Fixed return by reference
2014-03-07 08:25:55 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
if (EX(return_value)) {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
ZVAL_MAKE_REF(retval_ptr);
Z_ADDREF_P(retval_ptr);
ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
Improved return by reference handling
2014-10-07 18:38:37 +00:00
Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF;
Optimized ZEND_RETURN opcode to not allocate and copy return value if it is not used.
2008-04-11 09:43:28 +00:00
}
ZEND_RETURN is splitted into two new instructions ZEND_RETURN and ZEND_RETURN_BY_REF
2010-04-22 11:56:45 +00:00
} while (0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP1_VAR_PTR();
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Implement Generator::getReturn() Conflicts: Zend/zend_vm_execute.h
2015-02-19 19:17:37 +00:00
ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY)
Add dedicated opcode for returns from a generator Generators don't have a return value, so it doesn't make sense to have a shared implementation here.
2012-08-24 11:51:39 +00:00
{
Implement Generator::getReturn() Conflicts: Zend/zend_vm_execute.h
2015-02-19 19:17:37 +00:00
USE_OPLINE
zval *retval;
zend_free_op free_op1;
Generator related fixes
2014-02-26 09:58:59 +00:00
/* The generator object is stored in EX(return_value) */
zend_generator *generator = (zend_generator *) EX(return_value);
- generators API exported for extensions - improved RETURN sequence to avoid redundant check if op_array is a generator
2012-12-11 13:25:32 +00:00
Implement Generator::getReturn() Conflicts: Zend/zend_vm_execute.h
2015-02-19 19:17:37 +00:00
SAVE_OPLINE();
retval = GET_OP1_ZVAL_PTR(BP_VAR_R);
/* Copy return value into generator->retval */
if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
ZVAL_COPY_VALUE(&generator->retval, retval);
if (OP1_TYPE == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE(generator->retval))) {
zval_copy_ctor_func(&generator->retval);
}
}
} else if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) && Z_ISREF_P(retval)) {
ZVAL_COPY(&generator->retval, Z_REFVAL_P(retval));
FREE_OP1_IF_VAR();
} else {
ZVAL_COPY_VALUE(&generator->retval, retval);
if (OP1_TYPE == IS_CV) {
if (Z_OPT_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
}
}
- generators API exported for extensions - improved RETURN sequence to avoid redundant check if op_array is a generator
2012-12-11 13:25:32 +00:00
/* Close the generator to free up resources */
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_generator_close(generator, 1);
- generators API exported for extensions - improved RETURN sequence to avoid redundant check if op_array is a generator
2012-12-11 13:25:32 +00:00
/* Pass execution back to handling code */
ZEND_VM_RETURN();
Add dedicated opcode for returns from a generator Generators don't have a return value, so it doesn't make sense to have a shared implementation here.
2012-08-24 11:51:39 +00:00
}
Fixed bug #33318 (throw 1; results in Invalid opcode 108/1/8)
2005-06-16 14:20:00 +00:00
ZEND_VM_HANDLER(108, ZEND_THROW, CONST|TMP|VAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zval *value;
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
do {
if (OP1_TYPE == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
value = Z_REFVAL_P(value);
if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
break;
}
}
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Can only throw objects");
FREE_OP1();
HANDLE_EXCEPTION();
Exceptions triggered by undefined variable should be handled before FATAL error this is a enhancement of the fix for bug #64135
2013-02-16 14:22:22 +00:00
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
} while (0);
Exceptions triggered by undefined variable should be handled before FATAL error this is a enhancement of the fix for bug #64135
2013-02-16 14:22:22 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_exception_save();
Remove dead code from ZEND_THROW The IS_CONST case always throws an E_ERROR two lines above that, so no need to handle it further.
2014-05-06 18:02:26 +00:00
if (OP1_TYPE != IS_TMP_VAR) {
Avoid useles copy ctor
2014-04-21 09:19:52 +00:00
if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_throw_exception_object(value);
zend_exception_restore();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_IF_VAR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
zend_class_entry *ce, *catch_ce;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zend_object *exception;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* Check whether an exception has been thrown, if not, jump over code */
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_exception_restore();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (EG(exception) == NULL) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->extended_value]);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_CONTINUE(); /* CHECK_ME */
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) {
catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
catch_ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
fix bug #61782 - __clone/__destruct do not match other methods when checking access controls
2012-05-13 05:12:48 +00:00
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), catch_ce);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
Remove zend_get_class_entry function
2014-10-09 12:17:30 +00:00
ce = EG(exception)->ce;
Add DTrace probes
2010-04-24 13:32:30 +00:00
#ifdef HAVE_DTRACE
if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
Fixed #65431 (Discarded qualifiers from pointer target warnings when using --enable-dtrace) by Sixd
2013-08-14 03:42:39 +00:00
DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
Add DTrace probes
2010-04-24 13:32:30 +00:00
}
#endif /* HAVE_DTRACE */
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (ce != catch_ce) {
Improve "instanceof". Interfaces of the left operand should be checked only if the right operand is interafce itself.
2015-01-14 12:06:26 +00:00
if (!catch_ce || !instanceof_function(ce, catch_ce)) {
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
if (opline->result.num) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_throw_exception_internal(NULL);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->extended_value]);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_CONTINUE(); /* CHECK_ME */
}
}
Fixed exception handling in GOTO VM
2010-05-24 14:46:31 +00:00
exception = EG(exception);
Use specialized destructors when types of zvals are known.
2014-11-24 22:22:59 +00:00
zval_ptr_dtor(EX_VAR(opline->op2.var));
Use CV variable offset instead of CV variable number
2014-03-27 12:00:25 +00:00
ZVAL_OBJ(EX_VAR(opline->op2.var), EG(exception));
Fixed exception handling in GOTO VM
2010-05-24 14:46:31 +00:00
if (UNEXPECTED(EG(exception) != exception)) {
Changed data layout to allow more efficient operations
2014-04-02 10:34:44 +00:00
GC_REFCOUNT(EG(exception))++;
Fixed exception handling in GOTO VM
2010-05-24 14:46:31 +00:00
HANDLE_EXCEPTION();
} else {
EG(exception) = NULL;
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Removed redundant code
2010-06-22 14:15:08 +00:00
ZEND_VM_HANDLER(65, ZEND_SEND_VAL, CONST|TMP, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zval *value, *arg;
ZEND_SEND_* optimization
2014-04-22 08:33:00 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
ZEND_SEND_VAR and ZEND_SEND_VAL specialization
2014-07-07 22:13:53 +00:00
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
arg = ZEND_CALL_VAR(EX(call), opline->result.var);
ZEND_SEND_VAR and ZEND_SEND_VAL specialization
2014-07-07 22:13:53 +00:00
ZVAL_COPY_VALUE(arg, value);
if (OP1_TYPE == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE_P(arg))) {
zval_copy_ctor_func(arg);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
ZEND_SEND_VAR and ZEND_SEND_VAL specialization
2014-07-07 22:13:53 +00:00
ZEND_VM_NEXT_OPCODE();
}
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
ZEND_SEND_VAR and ZEND_SEND_VAL specialization
2014-07-07 22:13:53 +00:00
ZEND_VM_HANDLER(116, ZEND_SEND_VAL_EX, CONST|TMP, ANY)
{
USE_OPLINE
zval *value, *arg;
zend_free_op free_op1;
SAVE_OPLINE();
if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot pass parameter %d by reference", opline->op2.num);
FREE_UNFETCHED_OP1();
Fixed access on uninitialized data in Zend/tests/closure_019.phpt
2015-03-10 11:05:14 +00:00
arg = ZEND_CALL_VAR(EX(call), opline->result.var);
ZVAL_UNDEF(arg);
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
HANDLE_EXCEPTION();
ZEND_SEND_VAR and ZEND_SEND_VAL specialization
2014-07-07 22:13:53 +00:00
}
ZEND_SEND_* optimization
2014-04-22 08:33:00 +00:00
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
arg = ZEND_CALL_VAR(EX(call), opline->result.var);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZVAL_COPY_VALUE(arg, value);
ZEND_SEND_* optimization
2014-04-22 08:33:00 +00:00
if (OP1_TYPE == IS_CONST) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (UNEXPECTED(Z_OPT_COPYABLE_P(arg))) {
zval_copy_ctor_func(arg);
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
ZEND_VM_NEXT_OPCODE();
}
ZEND_SEND_VAR and ZEND_SEND_VAL specialization
2014-07-07 22:13:53 +00:00
ZEND_VM_HANDLER(117, ZEND_SEND_VAR, VAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zval *varptr, *arg;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
arg = ZEND_CALL_VAR(EX(call), opline->result.var);
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
if (Z_ISREF_P(varptr)) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZVAL_COPY(arg, Z_REFVAL_P(varptr));
Cleanup
2014-04-15 21:45:40 +00:00
FREE_OP1();
Avoid double zval copying in ZEND_SEND_VAL and zend_send_by_var_helper
2014-04-04 22:14:17 +00:00
} else {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZVAL_COPY_VALUE(arg, varptr);
Avoid double zval copying in ZEND_SEND_VAL and zend_send_by_var_helper
2014-04-04 22:14:17 +00:00
if (OP1_TYPE == IS_CV) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (Z_OPT_REFCOUNTED_P(arg)) Z_ADDREF_P(arg);
Avoid double zval copying in ZEND_SEND_VAL and zend_send_by_var_helper
2014-04-04 22:14:17 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR|CV, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Fixed parameter passing incompatibilities. Now it is possible to call array_pop(explode("&","1&2&3")) again.
2005-09-19 16:02:21 +00:00
zend_free_op free_op1;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zval *varptr, *arg;
Fixed parameter passing incompatibilities. Now it is possible to call array_pop(explode("&","1&2&3")) again.
2005-09-19 16:02:21 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
SEND_VAR_NO_REF optimization
2014-11-18 11:37:36 +00:00
if (!(opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND)) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
ZEND_SEND_VAR and ZEND_SEND_VAL specialization
2014-07-07 22:13:53 +00:00
ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_VAR);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
- MFH missing bits and pieces of the partial sync with head # This time i added: # ZEND_FE_RESET_VARIABLE # ZEND_FE_RESET_REFERENCE # and dapted parser,compiler,executor,interfaces to handle these flags # their purpose is to be able to pass whetehr foreach is done by ref to # the current() handler so that it can error out in case it is not capable # to comply to the requested return signature/protocol/semantics (weyp).
2006-05-11 21:07:39 +00:00
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
Fixed passing by reference
2014-03-04 19:54:05 +00:00
if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
Refactored ZVAL flags usage to simplify various checks (e.g. Z_REFCOUNTED(), candidate for GC, etc)
2014-04-03 11:26:23 +00:00
(Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
Removed a hack that allowed passing of function return value by reference depending on value of reference-counter (Fixed Zend/tests/bug35393.phpt test failure)
2014-08-20 11:04:40 +00:00
(Z_ISREF_P(varptr) || Z_TYPE_P(varptr) == IS_OBJECT)) {
Fixed return by reference
2014-03-07 08:25:55 +00:00
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
ZVAL_MAKE_REF(varptr);
ZEND_SEND_* optimization
2014-04-22 08:33:00 +00:00
if (OP1_TYPE == IS_CV) {
Z_ADDREF_P(varptr);
Fixed passing by reference
2014-03-04 19:54:05 +00:00
}
} else {
Fixed bug #48912 (Namespace causes unexpected strict behaviour with extract())
2009-07-28 12:35:27 +00:00
if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
!(opline->extended_value & ZEND_ARG_SEND_SILENT) :
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
Removed wrong warning message
2009-01-20 13:21:52 +00:00
zend_error(E_STRICT, "Only variables should be passed by reference");
}
Fixed passing by reference
2014-03-04 19:54:05 +00:00
}
SEND_VAR_NO_REF optimization
2014-11-18 11:37:36 +00:00
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
arg = ZEND_CALL_VAR(EX(call), opline->result.var);
SEND_VAR_NO_REF optimization
2014-11-18 11:37:36 +00:00
ZVAL_COPY_VALUE(arg, varptr);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zval *varptr, *arg;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
varptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(varptr == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Only variables can be passed by reference");
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
arg = ZEND_CALL_VAR(EX(call), opline->result.var);
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(varptr == &EG(error_zval))) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZVAL_NEW_REF(arg, &EG(uninitialized_zval));
Fixed bug #54262 (Crash when assigning value to a dimension in a non-array)
2011-03-16 11:14:33 +00:00
ZEND_VM_NEXT_OPCODE();
Fixed bug #52237 (Crash when passing the reference of the property of a non-object)
2010-07-05 09:08:35 +00:00
}
Fixed IS_INDIRECT handling when assign array element by reference. This might cause passing invalid pointer if the array could be resized before IS_INDIRECT usage. Now we use IS_REFERENCE instead of IS_INDIRECT. The following test crashed before: <?php $a = array(0,1,2,3,4,5,6,7); $a[8] = &$a[7]; ?>
2014-03-12 20:30:53 +00:00
if (Z_ISREF_P(varptr)) {
Fixed reference handling
2014-03-11 10:49:25 +00:00
Z_ADDREF_P(varptr);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZVAL_COPY_VALUE(arg, varptr);
Fixed reference counting
2014-04-11 08:43:22 +00:00
} else if (OP1_TYPE == IS_VAR &&
Optimized ZEND_SEND_REF
2014-04-22 09:10:53 +00:00
UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
Micro optimization
2014-11-13 14:36:08 +00:00
ZVAL_NEW_REF(arg, varptr);
Fixed IS_INDIRECT handling when assign array element by reference. This might cause passing invalid pointer if the array could be resized before IS_INDIRECT usage. Now we use IS_REFERENCE instead of IS_INDIRECT. The following test crashed before: <?php $a = array(0,1,2,3,4,5,6,7); $a[8] = &$a[7]; ?>
2014-03-12 20:30:53 +00:00
} else {
Micro optimization
2014-11-13 14:36:08 +00:00
ZVAL_NEW_REF(arg, varptr);
Z_ADDREF_P(arg);
ZVAL_REF(varptr, Z_REF_P(arg));
Fixed reference handling
2014-03-11 10:49:25 +00:00
}
Fixed reference counting
2014-04-11 08:43:22 +00:00
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
ZEND_VM_NEXT_OPCODE();
}
ZEND_SEND_VAR and ZEND_SEND_VAL specialization
2014-07-07 22:13:53 +00:00
ZEND_VM_HANDLER(66, ZEND_SEND_VAR_EX, VAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zval *varptr, *arg;
ZEND_SEND_* optimization
2014-04-22 08:33:00 +00:00
zend_free_op free_op1;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_SEND_VAR and ZEND_SEND_VAL specialization
2014-07-07 22:13:53 +00:00
if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_REF);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
SAVE_OPLINE();
ZEND_SEND_* optimization
2014-04-22 08:33:00 +00:00
varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
arg = ZEND_CALL_VAR(EX(call), opline->result.var);
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
if (Z_ISREF_P(varptr)) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZVAL_COPY(arg, Z_REFVAL_P(varptr));
ZEND_SEND_* optimization
2014-04-22 08:33:00 +00:00
FREE_OP1();
} else {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZVAL_COPY_VALUE(arg, varptr);
ZEND_SEND_* optimization
2014-04-22 08:33:00 +00:00
if (OP1_TYPE == IS_CV) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (Z_OPT_REFCOUNTED_P(arg)) Z_ADDREF_P(arg);
ZEND_SEND_* optimization
2014-04-22 08:33:00 +00:00
}
}
ZEND_VM_NEXT_OPCODE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
{
USE_OPLINE
zend_free_op free_op1;
zval *args;
int arg_num;
SAVE_OPLINE();
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
SAVE_OPLINE();
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
args = GET_OP1_ZVAL_PTR(BP_VAR_R);
Pack EX(num_args) into EX(This).u2.num_args
2014-11-28 07:28:49 +00:00
arg_num = ZEND_CALL_NUM_ARGS(EX(call)) + 1;
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
ZEND_VM_C_LABEL(send_again):
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
switch (Z_TYPE_P(args)) {
case IS_ARRAY: {
HashTable *ht = Z_ARRVAL_P(args);
Fix by-reference argument unpacking
2014-04-26 08:40:12 +00:00
zval *arg, *top;
More ZEND_HASH_FOREACH_* related changes
2014-04-18 20:08:14 +00:00
zend_string *name;
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht));
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
Introduced immutable arrays. They don't need to be copyed and may be used directly from SHM.
2014-05-29 14:21:56 +00:00
if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_TMP_VAR && Z_IMMUTABLE_P(args)) {
fix most of signed/unsigned warnings in vm def
2014-09-15 13:52:39 +00:00
uint32_t i;
Introduced immutable arrays. They don't need to be copyed and may be used directly from SHM.
2014-05-29 14:21:56 +00:00
int separate = 0;
/* check if any of arguments are going to be passed by reference */
for (i = 0; i < zend_hash_num_elements(ht); i++) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num + i)) {
Introduced immutable arrays. They don't need to be copyed and may be used directly from SHM.
2014-05-29 14:21:56 +00:00
separate = 1;
break;
}
}
if (separate) {
zval_copy_ctor(args);
ht = Z_ARRVAL_P(args);
}
}
Fixed compilation warnings
2014-04-22 13:46:34 +00:00
ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
More ZEND_HASH_FOREACH_* related changes
2014-04-18 20:08:14 +00:00
if (name) {
Errors converted to exceptions are not "recoverable" anymore.
2015-03-10 07:31:55 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot unpack array with string keys");
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
FREE_OP1();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
HANDLE_EXCEPTION();
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
top = ZEND_CALL_ARG(EX(call), arg_num);
if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
Introduced immutable arrays. They don't need to be copyed and may be used directly from SHM.
2014-05-29 14:21:56 +00:00
if (!Z_IMMUTABLE_P(args)) {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
ZVAL_MAKE_REF(arg);
Introduced immutable arrays. They don't need to be copyed and may be used directly from SHM.
2014-05-29 14:21:56 +00:00
Z_ADDREF_P(arg);
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
ZVAL_REF(top, Z_REF_P(arg));
Introduced immutable arrays. They don't need to be copyed and may be used directly from SHM.
2014-05-29 14:21:56 +00:00
} else {
ZVAL_DUP(top, arg);
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
} else if (Z_ISREF_P(arg)) {
code cleanup
2014-07-08 09:24:23 +00:00
ZVAL_COPY(top, Z_REFVAL_P(arg));
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
} else {
Fix by-reference argument unpacking
2014-04-26 08:40:12 +00:00
ZVAL_COPY(top, arg);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
}
Pack EX(num_args) into EX(This).u2.num_args
2014-11-28 07:28:49 +00:00
ZEND_CALL_NUM_ARGS(EX(call))++;
More ZEND_HASH_FOREACH_* related changes
2014-04-18 20:08:14 +00:00
arg_num++;
} ZEND_HASH_FOREACH_END();
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
break;
}
case IS_OBJECT: {
zend_class_entry *ce = Z_OBJCE_P(args);
zend_object_iterator *iter;
if (!ce || !ce->get_iterator) {
zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
break;
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
iter = ce->get_iterator(ce, args, 0);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
if (UNEXPECTED(!iter)) {
FREE_OP1();
if (!EG(exception)) {
zend_throw_exception_ex(
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
NULL, 0, "Object of type %s did not create an Iterator", ce->name->val
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
);
}
HANDLE_EXCEPTION();
}
if (iter->funcs->rewind) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
iter->funcs->rewind(iter);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
ZEND_VM_C_GOTO(unpack_iter_dtor);
}
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
for (; iter->funcs->valid(iter) == SUCCESS; ++arg_num) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zval *arg, *top;
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
ZEND_VM_C_GOTO(unpack_iter_dtor);
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
arg = iter->funcs->get_current_data(iter);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
ZEND_VM_C_GOTO(unpack_iter_dtor);
}
if (iter->funcs->get_current_key) {
zval key;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
iter->funcs->get_current_key(iter, &key);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
ZEND_VM_C_GOTO(unpack_iter_dtor);
}
if (Z_TYPE(key) == IS_STRING) {
Errors converted to exceptions are not "recoverable" anymore.
2015-03-10 07:31:55 +00:00
zend_error(E_EXCEPTION | E_ERROR,
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
"Cannot unpack Traversable with string keys");
Use specialized destructors when types of zvals are known.
2014-11-24 22:22:59 +00:00
zend_string_release(Z_STR(key));
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
ZEND_VM_C_GOTO(unpack_iter_dtor);
}
zval_dtor(&key);
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
zend_error(
E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
" by unpacking a Traversable, passing by-value instead", arg_num,
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
EX(call)->func->common.scope ? EX(call)->func->common.scope->name->val : "",
EX(call)->func->common.scope ? "::" : "",
EX(call)->func->common.function_name->val
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
);
}
trailing whitespace removal
2015-01-03 09:22:58 +00:00
Fixed argument unpacking
2014-02-26 12:17:28 +00:00
if (Z_ISREF_P(arg)) {
ZVAL_DUP(arg, Z_REFVAL_P(arg));
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
} else {
Fixed argument unpacking
2014-02-26 12:17:28 +00:00
if (Z_REFCOUNTED_P(arg)) Z_ADDREF_P(arg);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
top = ZEND_CALL_ARG(EX(call), arg_num);
ZVAL_COPY_VALUE(top, arg);
Pack EX(num_args) into EX(This).u2.num_args
2014-11-28 07:28:49 +00:00
ZEND_CALL_NUM_ARGS(EX(call))++;
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
iter->funcs->move_forward(iter);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
ZEND_VM_C_GOTO(unpack_iter_dtor);
}
}
ZEND_VM_C_LABEL(unpack_iter_dtor):
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_iterator_dtor(iter);
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
break;
}
IS_REFERENCE is unfrequent
2014-03-06 10:23:16 +00:00
case IS_REFERENCE:
args = Z_REFVAL_P(args);
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
ZEND_VM_C_GOTO(send_again);
IS_REFERENCE is unfrequent
2014-03-06 10:23:16 +00:00
break;
Implement argument unpacking RFC: https://wiki.php.net/rfc/argument_unpacking
2013-08-29 09:35:11 +00:00
default:
zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
}
FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY)
{
USE_OPLINE
zend_free_op free_op1;
zval *args;
SAVE_OPLINE();
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
args = GET_OP1_ZVAL_PTR(BP_VAR_R);
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
if (UNEXPECTED(Z_TYPE_P(args) != IS_ARRAY)) {
if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(args)) {
args = Z_REFVAL_P(args);
if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
ZEND_VM_C_GOTO(send_array);
}
}
Refactor as to not use call info, but add the flag to the op_array.
2015-03-19 17:30:11 +00:00
zend_internal_type_error(EX_USES_STRICT_TYPES(), "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
if (EX(call)->func->common.fn_flags & ZEND_ACC_CLOSURE) {
OBJ_RELEASE((zend_object*)EX(call)->func->common.prototype);
}
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (Z_OBJ(EX(call)->This)) {
OBJ_RELEASE(Z_OBJ(EX(call)->This));
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
}
EX(call)->func = (zend_function*)&zend_pass_function;
EX(call)->called_scope = NULL;
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
Z_OBJ(EX(call)->This) = NULL;
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
} else {
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
uint32_t arg_num;
HashTable *ht;
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
zval *arg, *param, tmp;
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_C_LABEL(send_array):
ht = Z_ARRVAL_P(args);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht));
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_TMP_VAR && Z_IMMUTABLE_P(args)) {
int separate = 0;
/* check if any of arguments are going to be passed by reference */
typo
2014-12-22 09:31:00 +00:00
for (arg_num = 0; arg_num < zend_hash_num_elements(ht); arg_num++) {
Fixed segfault
2014-12-22 04:18:56 +00:00
if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num + 1)) {
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
separate = 1;
break;
}
}
if (separate) {
zval_copy_ctor(args);
ht = Z_ARRVAL_P(args);
}
}
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
arg_num = 1;
param = ZEND_CALL_ARG(EX(call), 1);
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
ZEND_HASH_FOREACH_VAL(ht, arg) {
if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
// TODO: Scalar values don't have reference counters anymore.
// They are assumed to be 1, and they may be easily passed by
// reference now. However, previously scalars with refcount==1
// might be passed and with refcount>1 might not. We can support
// only single behavior ???
#if 0
if (Z_REFCOUNTED_P(arg) &&
// This solution breaks the following test (omit warning message) ???
// Zend/tests/bug61273.phpt
// ext/reflection/tests/bug42976.phpt
// ext/standard/tests/general_functions/call_user_func_array_variation_001.phpt
#else
if (!Z_REFCOUNTED_P(arg) ||
// This solution breaks the following test (emit warning message) ???
// ext/pdo_sqlite/tests/pdo_005.phpt
#endif
(!Z_ISREF_P(arg) && Z_REFCOUNT_P(arg) > 1)) {
if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given",
arg_num,
EX(call)->func->common.scope ? EX(call)->func->common.scope->name->val : "",
EX(call)->func->common.scope ? "::" : "",
EX(call)->func->common.function_name->val);
if (EX(call)->func->common.fn_flags & ZEND_ACC_CLOSURE) {
OBJ_RELEASE((zend_object*)EX(call)->func->common.prototype);
}
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (Z_OBJ(EX(call)->This)) {
OBJ_RELEASE(Z_OBJ(EX(call)->This));
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
}
EX(call)->func = (zend_function*)&zend_pass_function;
EX(call)->called_scope = NULL;
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
Z_OBJ(EX(call)->This) = NULL;
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
break;
}
if (Z_REFCOUNTED_P(arg)) {
Z_DELREF_P(arg);
}
ZVAL_DUP(&tmp, arg);
ZVAL_NEW_REF(arg, &tmp);
Z_ADDREF_P(arg);
} else if (!Z_ISREF_P(arg)) {
ZVAL_NEW_REF(arg, arg);
Z_ADDREF_P(arg);
} else if (Z_REFCOUNTED_P(arg)) {
Z_ADDREF_P(arg);
}
ZVAL_COPY_VALUE(param, arg);
} else if (Z_ISREF_P(arg) &&
/* don't separate references for __call */
(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) == 0) {
ZVAL_DUP(param, Z_REFVAL_P(arg));
} else {
ZVAL_COPY(param, arg);
}
Pack EX(num_args) into EX(This).u2.num_args
2014-11-28 07:28:49 +00:00
ZEND_CALL_NUM_ARGS(EX(call))++;
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
arg_num++;
param++;
} ZEND_HASH_FOREACH_END();
}
FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(120, ZEND_SEND_USER, VAR|CV, ANY)
{
USE_OPLINE
zval *arg, *param, tmp;
zend_free_op free_op1;
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
SAVE_OPLINE();
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
arg = GET_OP1_ZVAL_PTR(BP_VAR_R);
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
param = ZEND_CALL_VAR(EX(call), opline->result.var);
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
// TODO: Scalar values don't have reference counters anymore.
// They are assumed to be 1, and they may be easily passed by
// reference now. However, previously scalars with refcount==1
// might be passed and with refcount>1 might not. We can support
// only single behavior ???
#if 0
if (Z_REFCOUNTED_P(arg) &&
// This solution breaks the following test (omit warning message) ???
// Zend/tests/bug61273.phpt
// ext/reflection/tests/bug42976.phpt
// ext/standard/tests/general_functions/call_user_func_array_variation_001.phpt
#else
if (!Z_REFCOUNTED_P(arg) ||
// This solution breaks the following test (emit warning message) ???
// ext/pdo_sqlite/tests/pdo_005.phpt
#endif
Fixed incinsitency in passing arguments by reference to call_user_func()
2014-07-29 16:27:48 +00:00
(!Z_ISREF_P(arg) /*&& Z_REFCOUNT_P(arg) > 1???*/)) {
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given",
opline->op2.num,
EX(call)->func->common.scope ? EX(call)->func->common.scope->name->val : "",
EX(call)->func->common.scope ? "::" : "",
EX(call)->func->common.function_name->val);
if (EX(call)->func->common.fn_flags & ZEND_ACC_CLOSURE) {
OBJ_RELEASE((zend_object*)EX(call)->func->common.prototype);
}
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (Z_OBJ(EX(call)->This)) {
OBJ_RELEASE(Z_OBJ(EX(call)->This));
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
}
Fixed ext/standard/tests/general_functions/bug41970.phpt fails
2015-01-26 06:41:45 +00:00
ZVAL_UNDEF(param);
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
EX(call)->func = (zend_function*)&zend_pass_function;
EX(call)->called_scope = NULL;
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
Z_OBJ(EX(call)->This) = NULL;
Implement call_user_func() and call_user_func_array() using special opcodes. In some rare cases it leads to insignificant changes in error messages.
2014-07-10 20:32:18 +00:00
FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
if (Z_REFCOUNTED_P(arg)) {
Z_DELREF_P(arg);
}
ZVAL_DUP(&tmp, arg);
ZVAL_NEW_REF(arg, &tmp);
Z_ADDREF_P(arg);
} else if (!Z_ISREF_P(arg)) {
ZVAL_NEW_REF(arg, arg);
Z_ADDREF_P(arg);
} else if (Z_REFCOUNTED_P(arg)) {
Z_ADDREF_P(arg);
}
ZVAL_COPY_VALUE(param, arg);
} else if (Z_ISREF_P(arg) &&
/* don't separate references for __call */
(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) == 0) {
ZVAL_DUP(param, Z_REFVAL_P(arg));
} else {
ZVAL_COPY(param, arg);
}
FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
master renames phase 2
2014-08-25 17:28:33 +00:00
uint32_t arg_num = opline->op1.num;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Pack EX(num_args) into EX(This).u2.num_args
2014-11-28 07:28:49 +00:00
if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_verify_missing_arg(execute_data, arg_num);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
CHECK_EXCEPTION();
} else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
zend_verify_arg_type(EX(func), arg_num, param, NULL);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
master renames phase 2
2014-08-25 17:28:33 +00:00
uint32_t arg_num = opline->op1.num;
Revert "Merge remote-tracking branch 'origin/PHP-5.6'" This reverts commit 38229d13d14bb0bda736d52a9a4f25c121445692, reversing changes made to 77f172725a37c8ddee750bf6970529a1570fbc86.
2014-11-25 12:40:08 +00:00
zval *param;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
Pack EX(num_args) into EX(This).u2.num_args
2014-11-28 07:28:49 +00:00
if (arg_num > EX_NUM_ARGS()) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZVAL_COPY_VALUE(param, EX_CONSTANT(opline->op2));
Revert "Merge remote-tracking branch 'origin/PHP-5.6'" This reverts commit 38229d13d14bb0bda736d52a9a4f25c121445692, reversing changes made to 77f172725a37c8ddee750bf6970529a1570fbc86.
2014-11-25 12:40:08 +00:00
if (Z_OPT_CONSTANT_P(param)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zval_update_constant(param, 0);
Fixed support for undefined constants in RECV_INIT
2014-03-05 20:15:56 +00:00
} else {
Constant duplication optimization Argument receiving optimization
2014-04-03 23:55:27 +00:00
/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (UNEXPECTED(Z_OPT_COPYABLE_P(param))) {
zval_copy_ctor_func(param);
Constant duplication optimization Argument receiving optimization
2014-04-03 23:55:27 +00:00
}
Fixed support for undefined constants in RECV_INIT
2014-03-05 20:15:56 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2));
Optimized RECV_* opcodes
2014-04-04 10:36:34 +00:00
}
Optimized handlers for ZEND_RECV and ZEND_RECV_INIT opocdes
2008-04-24 15:45:46 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Implement variadic function syntax As per RFC: https://wiki.php.net/rfc/variadics
2013-09-26 16:39:17 +00:00
ZEND_VM_HANDLER(164, ZEND_RECV_VARIADIC, ANY, ANY)
{
USE_OPLINE
master renames phase 2
2014-08-25 17:28:33 +00:00
uint32_t arg_num = opline->op1.num;
Pack EX(num_args) into EX(This).u2.num_args
2014-11-28 07:28:49 +00:00
uint32_t arg_count = EX_NUM_ARGS();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *params;
Implement variadic function syntax As per RFC: https://wiki.php.net/rfc/variadics
2013-09-26 16:39:17 +00:00
SAVE_OPLINE();
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
params = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
Implement variadic function syntax As per RFC: https://wiki.php.net/rfc/variadics
2013-09-26 16:39:17 +00:00
if (arg_num <= arg_count) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zval *param;
Implement variadic function syntax As per RFC: https://wiki.php.net/rfc/variadics
2013-09-26 16:39:17 +00:00
array_init_size(params, arg_count - arg_num + 1);
API for fast construction of packed arrays
2014-12-23 16:08:28 +00:00
zend_hash_real_init(Z_ARRVAL_P(params), 1);
ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(params)) {
param = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
Fixed white spaces
2015-03-20 08:10:29 +00:00
do {
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
zend_verify_arg_type(EX(func), arg_num, param, NULL);
API for fast construction of packed arrays
2014-12-23 16:08:28 +00:00
if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
ZEND_HASH_FILL_ADD(param);
param++;
} while (++arg_num <= arg_count);
} else {
do {
if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
ZEND_HASH_FILL_ADD(param);
param++;
} while (++arg_num <= arg_count);
}
} ZEND_HASH_FILL_END();
Implement variadic function syntax As per RFC: https://wiki.php.net/rfc/variadics
2013-09-26 16:39:17 +00:00
} else {
array_init(params);
}
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(52, ZEND_BOOL, CONST|TMPVAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
zval *val;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
val = GET_OP1_ZVAL_PTR(BP_VAR_R);
trailing whitespace removal
2015-01-03 09:22:58 +00:00
if (Z_TYPE_P(val) == IS_TRUE) {
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
ZVAL_TRUE(EX_VAR(opline->result.var));
} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
ZVAL_FALSE(EX_VAR(opline->result.var));
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
Improved BOOL, BOOL_NOT and conditional jumps
2014-12-05 14:04:15 +00:00
FREE_OP1();
CHECK_EXCEPTION();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Removed support for break/continue $var syntax
2010-11-24 12:19:56 +00:00
ZEND_VM_HANDLER(50, ZEND_BRK, ANY, CONST)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Fixed bug #35017 (Exception thrown in error handler may cause unexpected behavior)
2005-10-31 19:25:14 +00:00
zend_brk_cont_element *el;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
el = zend_brk_cont(Z_LVAL_P(EX_CONSTANT(opline->op2)), opline->op1.opline_num,
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
&EX(func)->op_array, execute_data);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_JMP(EX(func)->op_array.opcodes + el->brk);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Removed support for break/continue $var syntax
2010-11-24 12:19:56 +00:00
ZEND_VM_HANDLER(51, ZEND_CONT, ANY, CONST)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Fixed bug #35017 (Exception thrown in error handler may cause unexpected behavior)
2005-10-31 19:25:14 +00:00
zend_brk_cont_element *el;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
el = zend_brk_cont(Z_LVAL_P(EX_CONSTANT(opline->op2)), opline->op1.opline_num,
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
&EX(func)->op_array, execute_data);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_JMP(EX(func)->op_array.opcodes + el->cont);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
MFH: Implemented "jump label" operator (limited "goto") [DOC]
2008-03-28 14:35:01 +00:00
ZEND_VM_HANDLER(100, ZEND_GOTO, ANY, CONST)
{
zend_op *brk_opline;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
MFH: Implemented "jump label" operator (limited "goto") [DOC]
2008-03-28 14:35:01 +00:00
zend_brk_cont_element *el;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
el = zend_brk_cont(Z_LVAL_P(EX_CONSTANT(opline->op2)), opline->extended_value,
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
&EX(func)->op_array, execute_data);
MFH: Implemented "jump label" operator (limited "goto") [DOC]
2008-03-28 14:35:01 +00:00
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
brk_opline = EX(func)->op_array.opcodes + el->brk;
MFH: Implemented "jump label" operator (limited "goto") [DOC]
2008-03-28 14:35:01 +00:00
Use zval_ptr_dtor_nogc() to free IS_TMP_VAR operands. Removed ZEND_SWITCH_FREE opcode (ZEND_FREE used instead).
2014-09-23 13:21:29 +00:00
if (brk_opline->opcode == ZEND_FREE) {
Simplify code
2014-06-05 14:42:17 +00:00
if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
Use zval_ptr_dtor_nogc() to free IS_TMP_VAR operands. Removed ZEND_SWITCH_FREE opcode (ZEND_FREE used instead).
2014-09-23 13:21:29 +00:00
zval_ptr_dtor_nogc(EX_VAR(brk_opline->op1.var));
Simplify code
2014-06-05 14:42:17 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
} else if (brk_opline->opcode == ZEND_FE_FREE) {
if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
zval *var = EX_VAR(brk_opline->op1.var);
if (Z_TYPE_P(var) != IS_ARRAY && Z_FE_ITER_P(var) != (uint32_t)-1) {
zend_hash_iterator_del(Z_FE_ITER_P(var));
}
zval_ptr_dtor_nogc(var);
}
MFH: Implemented "jump label" operator (limited "goto") [DOC]
2008-03-28 14:35:01 +00:00
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op1));
MFH: Implemented "jump label" operator (limited "goto") [DOC]
2008-03-28 14:35:01 +00:00
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
zval *op1, *op2, *result;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_LVAL_P(op1) == Z_LVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
ZVAL_BOOL(EX_VAR(opline->result.var), (double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_DVAL_P(op1) == Z_DVAL_P(op2));
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
ZVAL_BOOL(EX_VAR(opline->result.var), Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
if (Z_STR_P(op1) == Z_STR_P(op2)) {
ZVAL_TRUE(EX_VAR(opline->result.var));
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
} else if (Z_STRVAL_P(op1)[0] > '9' || Z_STRVAL_P(op2)[0] > '9') {
if (Z_STRLEN_P(op1) != Z_STRLEN_P(op2)) {
ZVAL_FALSE(EX_VAR(opline->result.var));
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
} else {
ZVAL_BOOL(EX_VAR(opline->result.var), memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) == 0);
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
}
} else {
ZVAL_BOOL(EX_VAR(opline->result.var), zendi_smart_strcmp(op1, op2) == 0);
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
}
}
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Embed "fast" operator functions (add, sub, increment, etc) into executor with additional optimizations
2015-03-17 15:53:19 +00:00
SAVE_OPLINE();
if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
}
if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
}
result = EX_VAR(opline->result.var);
compare_function(result, op1, op2);
ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Embed FETCH_CLASS <string> into the following NEW
2014-10-23 07:52:34 +00:00
ZEND_VM_HANDLER(68, ZEND_NEW, CONST|VAR, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval object_zval;
Merge three opcodes (ZEND_NEW, ZEND_JMP_NO_CTOR, ZEND_INIT_CTOR) into one (ZEND_NEW). There was no real reason for this anymore and API should be changed before 5.1
2005-06-10 07:56:40 +00:00
zend_function *constructor;
Embed FETCH_CLASS <string> into the following NEW
2014-10-23 07:52:34 +00:00
zend_class_entry *ce;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Embed FETCH_CLASS <string> into the following NEW
2014-10-23 07:52:34 +00:00
if (OP1_TYPE == IS_CONST) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) {
ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
Embed FETCH_CLASS <string> into the following NEW
2014-10-23 07:52:34 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, 0);
Embed FETCH_CLASS <string> into the following NEW
2014-10-23 07:52:34 +00:00
if (UNEXPECTED(ce == NULL)) {
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce);
Embed FETCH_CLASS <string> into the following NEW
2014-10-23 07:52:34 +00:00
}
} else {
ce = Z_CE_P(EX_VAR(opline->op1.var));
}
Made ZEND_ACC_TRAIT a saner value CC_TRAIT valued as 0x120 is too magical to be comprehensible by others.
2015-02-12 22:19:14 +00:00
if (UNEXPECTED((ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) != 0)) {
Embed FETCH_CLASS <string> into the following NEW
2014-10-23 07:52:34 +00:00
if (ce->ce_flags & ZEND_ACC_INTERFACE) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot instantiate interface %s", ce->name->val);
Made ZEND_ACC_TRAIT a saner value CC_TRAIT valued as 0x120 is too magical to be comprehensible by others.
2015-02-12 22:19:14 +00:00
} else if (ce->ce_flags & ZEND_ACC_TRAIT) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot instantiate trait %s", ce->name->val);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot instantiate abstract class %s", ce->name->val);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Embed FETCH_CLASS <string> into the following NEW
2014-10-23 07:52:34 +00:00
object_init_ex(&object_zval, ce);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
constructor = Z_OBJ_HT(object_zval)->get_constructor(Z_OBJ(object_zval));
Merge three opcodes (ZEND_NEW, ZEND_JMP_NO_CTOR, ZEND_INIT_CTOR) into one (ZEND_NEW). There was no real reason for this anymore and API should be changed before 5.1
2005-06-10 07:56:40 +00:00
if (constructor == NULL) {
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (EXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), &object_zval);
Merge three opcodes (ZEND_NEW, ZEND_JMP_NO_CTOR, ZEND_INIT_CTOR) into one (ZEND_NEW). There was no real reason for this anymore and API should be changed before 5.1
2005-06-10 07:56:40 +00:00
} else {
Use specialized destructors when types of zvals are known.
2014-11-24 22:22:59 +00:00
OBJ_RELEASE(Z_OBJ(object_zval));
Merge three opcodes (ZEND_NEW, ZEND_JMP_NO_CTOR, ZEND_INIT_CTOR) into one (ZEND_NEW). There was no real reason for this anymore and API should be changed before 5.1
2005-06-10 07:56:40 +00:00
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
Merge three opcodes (ZEND_NEW, ZEND_JMP_NO_CTOR, ZEND_INIT_CTOR) into one (ZEND_NEW). There was no real reason for this anymore and API should be changed before 5.1
2005-06-10 07:56:40 +00:00
} else {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
/* We are not handling overloaded classes right now */
EX(call) = zend_vm_stack_push_call_frame(
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
ZEND_CALL_FUNCTION | ZEND_CALL_CTOR |
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
(EXPECTED(RETURN_VALUE_USED(opline)) ? 0 : ZEND_CALL_CTOR_RESULT_UNUSED),
Merged EX(frame_kind) and EX(flags) into single word
2014-10-07 13:12:12 +00:00
constructor,
opline->extended_value,
Embed FETCH_CLASS <string> into the following NEW
2014-10-23 07:52:34 +00:00
ce,
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
Z_OBJ(object_zval),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
EX(call));
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (EXPECTED(RETURN_VALUE_USED(opline))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), &object_zval);
Partial fix that allows internal constructors to set $this to null. The address of $this passed to drectly called internal constructor in execute_data->return_value. Internal constructors should use ZEND_CTOR_MAKE_NULL() macro (insted of previous ZEND_NULL(EG(This))) to do the work. This patch doesn't fix the problem for indirectly called constructors. e.g. parant::__construct().
2014-07-09 07:57:42 +00:00
EX(call)->return_value = EX_VAR(opline->result.var);
} else {
EX(call)->return_value = NULL;
executor optimization
2007-12-14 14:14:50 +00:00
}
- MFH missing bits and pieces of the partial sync with head # This time i added: # ZEND_FE_RESET_VARIABLE # ZEND_FE_RESET_REFERENCE # and dapted parser,compiler,executor,interfaces to handle these flags # their purpose is to be able to pass whetehr foreach is done by ref to # the current() handler so that it can error out in case it is not capable # to comply to the requested return signature/protocol/semantics (weyp).
2006-05-11 21:07:39 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
Merge three opcodes (ZEND_NEW, ZEND_JMP_NO_CTOR, ZEND_INIT_CTOR) into one (ZEND_NEW). There was no real reason for this anymore and API should be changed before 5.1
2005-06-10 07:56:40 +00:00
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMPVAR|UNUSED|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *obj;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_class_entry *ce;
zend_function *clone;
zend_object_clone_obj_t clone_call;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
obj = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
do {
if (OP1_TYPE == IS_CONST ||
(OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
obj = Z_REFVAL_P(obj);
if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
break;
}
}
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "__clone method called on non-object");
FREE_OP1();
HANDLE_EXCEPTION();
Exceptions triggered by undefined variable should be handled before FATAL error this is a enhancement of the fix for bug #64135
2013-02-16 14:22:22 +00:00
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
} while (0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ce = Z_OBJCE_P(obj);
clone = ce ? ce->clone : NULL;
clone_call = Z_OBJ_HT_P(obj)->clone_obj;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (UNEXPECTED(clone_call == NULL)) {
Fixed bug #38234 (Exception in __clone makes memory leak)
2006-07-27 10:44:03 +00:00
if (ce) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val);
Fixed bug #38234 (Exception in __clone makes memory leak)
2006-07-27 10:44:03 +00:00
} else {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Trying to clone an uncloneable object");
Fixed bug #38234 (Exception in __clone makes memory leak)
2006-07-27 10:44:03 +00:00
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
FREE_OP1();
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
if (ce && clone) {
if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
/* Ensure that if we're calling a private function, we're allowed to do so.
*/
Get rid of EX(scope). In most cases we use EG(scope) anyway. EX(scope) was used to switch EG(scope) back after call, but it's possibleto use EX(func)->common.scope instead.
2014-11-28 07:21:18 +00:00
if (UNEXPECTED(ce != EG(scope))) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
FREE_OP1();
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
/* Ensure that if we're calling a protected function, we're allowed to do so.
*/
Get rid of EX(scope). In most cases we use EG(scope) anyway. EX(scope) was used to switch EG(scope) back after call, but it's possibleto use EX(func)->common.scope instead.
2014-11-28 07:21:18 +00:00
if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
FREE_OP1();
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (EXPECTED(EG(exception) == NULL)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj));
Wrap RETURN_VALUE_USED() with EXPECTED() or UNEXPECTED() macros according to more frequent usage patterns.
2014-12-09 14:07:12 +00:00
if (UNEXPECTED(!RETURN_VALUE_USED(opline)) || UNEXPECTED(EG(exception) != NULL)) {
Use specialized destructors when types of zvals are known.
2014-11-24 22:22:59 +00:00
OBJ_RELEASE(Z_OBJ_P(EX_VAR(opline->result.var)));
Proper fix for bug #37707 ("clone $x" must call __clone() enven if result value is not used)
2006-06-08 08:56:27 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Namespaces
2007-09-28 19:52:53 +00:00
ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (OP1_TYPE == IS_UNUSED) {
- Reimplemented ZEND_INIT_FCALL_BY_NAME and ZEND_INIT_NS_FCALL_BY_NAME to use literals instead of additional operands - Optimized access to global constants
2010-04-27 12:09:13 +00:00
zend_constant *c;
zval *retval;
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) {
c = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
} else if ((c = zend_quick_get_constant(EX_CONSTANT(opline->op2) + 1, opline->extended_value)) == NULL) {
Namespace resolution streamlining patch [DOC] new resolution rules should be documented soon
2008-11-11 19:45:29 +00:00
if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
char *actual = (char *)zend_memrchr(Z_STRVAL_P(EX_CONSTANT(opline->op2)), '\\', Z_STRLEN_P(EX_CONSTANT(opline->op2)));
Fixed memory leak in ZEND_JMPZ_EX (op1 and result may share same slot)
2014-10-30 08:00:08 +00:00
if (!actual) {
Use specialized macro for string zval creation
2015-03-12 13:53:51 +00:00
ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_STR_P(EX_CONSTANT(opline->op2)));
Namespace resolution streamlining patch [DOC] new resolution rules should be documented soon
2008-11-11 19:45:29 +00:00
} else {
actual++;
Save memory allocating
2014-10-30 08:55:40 +00:00
ZVAL_STRINGL(EX_VAR(opline->result.var),
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
actual, Z_STRLEN_P(EX_CONSTANT(opline->op2)) - (actual - Z_STRVAL_P(EX_CONSTANT(opline->op2))));
- Next step in namespaces, using / as namespace separator.
2008-11-04 15:58:55 +00:00
}
Namespace resolution streamlining patch [DOC] new resolution rules should be documented soon
2008-11-11 19:45:29 +00:00
/* non-qualified constant - allow text substitution */
Save memory allocating
2014-10-30 08:55:40 +00:00
zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
Z_STRVAL_P(EX_VAR(opline->result.var)), Z_STRVAL_P(EX_VAR(opline->result.var)));
- Reimplemented ZEND_INIT_FCALL_BY_NAME and ZEND_INIT_NS_FCALL_BY_NAME to use literals instead of additional operands - Optimized access to global constants
2010-04-27 12:09:13 +00:00
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
- Next step in namespaces, using / as namespace separator.
2008-11-04 15:58:55 +00:00
} else {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2)));
HANDLE_EXCEPTION();
Fixed bug #43344 (Wrong error message for undefined namespace constant)
2007-12-07 17:11:24 +00:00
}
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), c);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
retval = EX_VAR(opline->result.var);
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
ZVAL_COPY_VALUE(retval, &c->value);
if (Z_OPT_COPYABLE_P(retval) || Z_OPT_REFCOUNTED_P(retval)) {
Fixed bug #67725 (now we create immutable arrays only in SHM)
2014-08-05 11:38:43 +00:00
if (Z_OPT_COPYABLE_P(retval)) {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
zval_copy_ctor_func(retval);
} else {
Z_ADDREF_P(retval);
}
}
Namespaces
2007-09-28 19:52:53 +00:00
} else {
- Next step in namespaces, using / as namespace separator.
2008-11-04 15:58:55 +00:00
/* class constant */
Namespaces
2007-09-28 19:52:53 +00:00
zend_class_entry *ce;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *value;
ws
2007-10-03 06:49:15 +00:00
Namespaces
2007-09-28 19:52:53 +00:00
if (OP1_TYPE == IS_CONST) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) {
value = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
Improve class constant fetch fix Dereference the cached constant for Test::TEST as well (and not just self::TEST). Also improve the phpt file to test this case as well - previously this only manifested with opcache enabled, due to literal sharing. Additionally the Z_TYPE_P != IS_REFERENCE assertion is now moved into the TMP_VAR fetching code (as it applies to more than just property assignments.)
2014-05-29 09:17:33 +00:00
ZVAL_DEREF(value);
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_DUP(EX_VAR(opline->result.var), value);
Optimized conditions order
2014-06-03 05:45:09 +00:00
ZEND_VM_C_GOTO(constant_fetch_end);
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
} else if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) {
ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, 0);
Fixed bug #65254 (Exception not catchable when exception thrown in autoload with a namespace).
2013-07-14 03:47:06 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
}
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
if (UNEXPECTED(ce == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1)));
HANDLE_EXCEPTION();
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce);
Namespaces
2007-09-28 19:52:53 +00:00
}
} else {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ce = Z_CE_P(EX_VAR(opline->op1.var));
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce)) != NULL) {
Fix class constant fetching If a class is extended after the constant fetch has been cached the cached value will be turned into a reference. On the next fetch the polymorphic cache will return this reference, which will be directly returned. The object assignment code then dereferences this result and performs a shallow copy, which is invalid for references. This subsequently leads to the constant value being prematurely freed. This is fixed by dereferencing the value returned from the polymorphic cache. Furthermore the incorrect dereference from in the object assignment code is replaced with an assertion that we're dealing with a non-reference, so ensure that this kind of problem cannot go unnoticed in the future.
2014-05-28 22:02:13 +00:00
ZVAL_DEREF(value);
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_DUP(EX_VAR(opline->result.var), value);
Optimized conditions order
2014-06-03 05:45:09 +00:00
ZEND_VM_C_GOTO(constant_fetch_end);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
Namespaces
2007-09-28 19:52:53 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(EX_CONSTANT(opline->op2)))) != NULL)) {
Fix class constant fetching If a class is extended after the constant fetch has been cached the cached value will be turned into a reference. On the next fetch the polymorphic cache will return this reference, which will be directly returned. The object assignment code then dereferences this result and performs a shallow copy, which is invalid for references. This subsequently leads to the constant value being prematurely freed. This is fixed by dereferencing the value returned from the polymorphic cache. Furthermore the incorrect dereference from in the object assignment code is replaced with an assertion that we're dealing with a non-reference, so ensure that this kind of problem cannot go unnoticed in the future.
2014-05-28 22:02:13 +00:00
ZVAL_DEREF(value);
Constant duplication optimization Argument receiving optimization
2014-04-03 23:55:27 +00:00
if (Z_CONSTANT_P(value)) {
Namespaces
2007-09-28 19:52:53 +00:00
EG(scope) = ce;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zval_update_constant(value, 1);
Get rid of EX(scope). In most cases we use EG(scope) anyway. EX(scope) was used to switch EG(scope) back after call, but it's possibleto use EX(func)->common.scope instead.
2014-11-28 07:21:18 +00:00
EG(scope) = EX(func)->op_array.scope;
Namespaces
2007-09-28 19:52:53 +00:00
}
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
if (OP1_TYPE == IS_CONST) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), value);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce, value);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_DUP(EX_VAR(opline->result.var), value);
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
} else if (Z_STRLEN_P(EX_CONSTANT(opline->op2)) == sizeof("class")-1 && memcmp(Z_STRVAL_P(EX_CONSTANT(opline->op2)), "class", sizeof("class") - 1) == 0) {
Class Name Resolution As Scalar Via "class" Keyword
2013-01-19 00:00:47 +00:00
/* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
Avoid double IS_INTERNED() check
2014-09-19 13:32:50 +00:00
ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
Namespaces
2007-09-28 19:52:53 +00:00
} else {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2)));
HANDLE_EXCEPTION();
Namespaces
2007-09-28 19:52:53 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Optimized conditions order
2014-06-03 05:45:09 +00:00
ZEND_VM_C_LABEL(constant_fetch_end):
Fixed disallowal of array usage in constants at run-time Added at the same time the possibility of array dereferencing to complete the set of features (useful application of arrays in constants)
2014-04-11 16:21:46 +00:00
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
zend_free_op free_op1;
Fixed ref hanlding in ADD_ARRAY_ELEMENT (by ext/standard/tests/array/bug30074.phpt)
2014-03-09 11:42:08 +00:00
zval *expr_ptr, new_expr;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Use symbolic names instead of magic constants + optimization
2014-04-22 22:47:41 +00:00
if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) &&
(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
expr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(expr_ptr == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot create references to/from string offsets");
FREE_OP1_VAR_PTR();
More accurate reference counting on closures
2015-03-10 20:04:41 +00:00
zend_array_destroy(Z_ARRVAL_P(EX_VAR(opline->result.var)));
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
HANDLE_EXCEPTION();
Fixed crash on attempt to insert reference to string offset into an array
2010-10-22 11:05:22 +00:00
}
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
ZVAL_MAKE_REF(expr_ptr);
REFERENCE is always REFCOUNTED
2014-03-13 18:07:37 +00:00
Z_ADDREF_P(expr_ptr);
Use symbolic names instead of magic constants + optimization
2014-04-22 22:47:41 +00:00
FREE_OP1_VAR_PTR();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
Fixed reference counting
2014-04-14 21:16:09 +00:00
expr_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
Replace IS_OP?_TMP_FREE() with more clear (OP?_TYPE == IS_TMP_VAR)
2014-09-22 08:47:10 +00:00
if (OP1_TYPE == IS_TMP_VAR) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_COPY_VALUE(&new_expr, expr_ptr);
expr_ptr = &new_expr;
Fixed ref hanlding in ADD_ARRAY_ELEMENT (by ext/standard/tests/array/bug30074.phpt)
2014-03-09 11:42:08 +00:00
} else if (OP1_TYPE == IS_CONST) {
Avoid copying of immutable arrays
2014-06-02 22:43:53 +00:00
if (!Z_IMMUTABLE_P(expr_ptr)) {
ZVAL_DUP(&new_expr, expr_ptr);
expr_ptr = &new_expr;
}
Specialization (only IS_VAR ad IS_CV operands may be references)
2014-09-22 12:17:35 +00:00
} else if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) && Z_ISREF_P(expr_ptr)) {
expr_ptr = Z_REFVAL_P(expr_ptr);
if (Z_REFCOUNTED_P(expr_ptr)) Z_ADDREF_P(expr_ptr);
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP1_IF_VAR();
Fix Z_COUNTED() -> Z_REFCOUNTED()
2014-02-21 15:19:52 +00:00
} else if (OP1_TYPE == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
MFH: Added macros for managing zval refcounts and is_ref statuses
2007-10-07 05:22:07 +00:00
Z_ADDREF_P(expr_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (OP2_TYPE != IS_UNUSED) {
zend_free_op free_op2;
IS_REFERENCE is unfrequent
2014-03-06 10:23:16 +00:00
zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
Use symbolic names instead of magic constants + optimization
2014-04-22 22:47:41 +00:00
zend_string *str;
master renames phase 1
2014-08-25 17:24:55 +00:00
zend_ulong hval;
fix UMR when variable name is an object and __toString is used # zend_call_function checks IS_REF on This
2011-03-16 05:25:02 +00:00
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
ZEND_VM_C_LABEL(add_again):
- MFH missing bits and pieces of the partial sync with head # This time i added: # ZEND_FE_RESET_VARIABLE # ZEND_FE_RESET_REFERENCE # and dapted parser,compiler,executor,interfaces to handle these flags # their purpose is to be able to pass whetehr foreach is done by ref to # the current() handler so that it can error out in case it is not capable # to comply to the requested return signature/protocol/semantics (weyp).
2006-05-11 21:07:39 +00:00
switch (Z_TYPE_P(offset)) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
case IS_DOUBLE:
master renames phase 1
2014-08-25 17:24:55 +00:00
hval = zend_dval_to_lval(Z_DVAL_P(offset));
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
ZEND_VM_C_GOTO(num_index);
master renames phase 1
2014-08-25 17:24:55 +00:00
case IS_LONG:
hval = Z_LVAL_P(offset);
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
ZEND_VM_C_LABEL(num_index):
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
break;
case IS_STRING:
Use symbolic names instead of magic constants + optimization
2014-04-22 22:47:41 +00:00
str = Z_STR_P(offset);
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
if (OP2_TYPE != IS_CONST) {
Simplified and optimized ZEND_HANDLE_NUMERIC()
2014-06-03 09:10:42 +00:00
if (ZEND_HANDLE_NUMERIC(str, hval)) {
ZEND_VM_C_GOTO(num_index);
}
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
}
trailing whitespace removal
2015-01-03 09:22:58 +00:00
ZEND_VM_C_LABEL(str_index):
Use symbolic names instead of magic constants + optimization
2014-04-22 22:47:41 +00:00
zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
break;
case IS_NULL:
Use symbolic names instead of magic constants + optimization
2014-04-22 22:47:41 +00:00
str = STR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index);
Split IS_BOOL into IS_FALSE and IS_TRUE
2014-04-30 14:32:42 +00:00
case IS_FALSE:
hval = 0;
ZEND_VM_C_GOTO(num_index);
case IS_TRUE:
hval = 1;
ZEND_VM_C_GOTO(num_index);
IS_REFERENCE is unfrequent
2014-03-06 10:23:16 +00:00
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
ZEND_VM_C_GOTO(add_again);
IS_REFERENCE is unfrequent
2014-03-06 10:23:16 +00:00
break;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
default:
zend_error(E_WARNING, "Illegal offset type");
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval_ptr_dtor(expr_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* do nothing */
break;
}
FREE_OP2();
} else {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(71, ZEND_INIT_ARRAY, CONST|TMP|VAR|UNUSED|CV, CONST|TMPVAR|UNUSED|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Use symbolic names instead of magic constants + optimization
2014-04-22 22:47:41 +00:00
zval *array;
master renames phase 2
2014-08-25 17:28:33 +00:00
uint32_t size;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Small optimization of ZEND_INIT_ARRAY/ZEND_ADD_ARRAY_ELEMENT. (Nuno, Dmitry)
2006-09-18 14:23:52 +00:00
Use symbolic names instead of magic constants + optimization
2014-04-22 22:47:41 +00:00
array = EX_VAR(opline->result.var);
if (OP1_TYPE != IS_UNUSED) {
size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
} else {
size = 0;
}
ZVAL_NEW_ARR(array);
zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
Initialize hash as unpacked if it contains string keys
2014-04-22 19:33:49 +00:00
if (OP1_TYPE != IS_UNUSED) {
/* Explicitly initialize array as not-packed if flag is set */
Use symbolic names instead of magic constants + optimization
2014-04-22 22:47:41 +00:00
if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
zend_hash_real_init(Z_ARRVAL_P(array), 0);
Initialize hash as unpacked if it contains string keys
2014-04-22 19:33:49 +00:00
}
}
Small optimization of ZEND_INIT_ARRAY/ZEND_ADD_ARRAY_ELEMENT. (Nuno, Dmitry)
2006-09-18 14:23:52 +00:00
if (OP1_TYPE == IS_UNUSED) {
ZEND_VM_NEXT_OPCODE();
Fixed ability to build unspecialized executor
2015-02-26 14:53:03 +00:00
#if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Small optimization of ZEND_INIT_ARRAY/ZEND_ADD_ARRAY_ELEMENT. (Nuno, Dmitry)
2006-09-18 14:23:52 +00:00
} else {
ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ADD_ARRAY_ELEMENT);
#endif
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *expr;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *result = EX_VAR(opline->result.var);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
IS_REFERENCE is unfrequent
2014-03-06 10:23:16 +00:00
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
switch (opline->extended_value) {
case IS_NULL:
Comment out cast_object for IS_NULL
2014-04-26 11:17:26 +00:00
/* This code is taken from convert_to_null. However, it does not seems very useful,
* because a conversion to null always results in the same value. This could only
* be relevant if a cast_object handler for IS_NULL has some kind of side-effect. */
#if 0
Uhm, do we really need to support that?
2014-04-25 13:41:23 +00:00
if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
ZVAL_DEREF(expr);
}
if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->cast_object) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (Z_OBJ_HT_P(expr)->cast_object(expr, result, IS_NULL) == SUCCESS) {
Uhm, do we really need to support that?
2014-04-25 13:41:23 +00:00
break;
}
}
Comment out cast_object for IS_NULL
2014-04-26 11:17:26 +00:00
#endif
Uhm, do we really need to support that?
2014-04-25 13:41:23 +00:00
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
ZVAL_NULL(result);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
break;
Split IS_BOOL into IS_FALSE and IS_TRUE
2014-04-30 14:32:42 +00:00
case _IS_BOOL:
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ZVAL_BOOL(result, zend_is_true(expr));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
break;
master renames phase 1
2014-08-25 17:24:55 +00:00
case IS_LONG:
ZVAL_LONG(result, zval_get_long(expr));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
break;
case IS_DOUBLE:
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
ZVAL_DOUBLE(result, zval_get_double(expr));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
break;
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
case IS_STRING:
ZVAL_STR(result, zval_get_string(expr));
break;
default:
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
if (OP1_TYPE & (IS_VAR|IS_CV)) {
ZVAL_DEREF(expr);
}
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
/* If value is already of correct type, return it directly */
if (Z_TYPE_P(expr) == opline->extended_value) {
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
ZVAL_COPY_VALUE(result, expr);
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
if (OP1_TYPE == IS_CONST) {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
zval_copy_ctor_func(result);
}
} else if (OP1_TYPE != IS_TMP_VAR) {
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
Fixed bug #42772 (Storing $this in a static var fails while handling a cast to string)
2007-10-03 08:02:36 +00:00
}
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
Fix array/object cast of refcounted tmp var
2014-10-13 12:51:53 +00:00
FREE_OP1_IF_VAR();
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
if (opline->extended_value == IS_ARRAY) {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
if (Z_TYPE_P(expr) != IS_OBJECT) {
ZVAL_NEW_ARR(result);
zend_hash_init(Z_ARRVAL_P(result), 8, NULL, ZVAL_PTR_DTOR, 0);
if (Z_TYPE_P(expr) != IS_NULL) {
expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
if (OP1_TYPE == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
zval_copy_ctor_func(expr);
}
More fixes for array/object casts with temporary variables
2014-10-13 13:19:23 +00:00
} else {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
}
}
} else {
ZVAL_COPY_VALUE(result, expr);
More fixes for array/object casts with temporary variables
2014-10-13 13:19:23 +00:00
Z_ADDREF_P(result);
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
convert_to_array(result);
}
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
} else {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
if (Z_TYPE_P(expr) != IS_ARRAY) {
object_init(result);
if (Z_TYPE_P(expr) != IS_NULL) {
expr = zend_hash_str_add_new(Z_OBJPROP_P(result), "scalar", sizeof("scalar")-1, expr);
if (OP1_TYPE == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
zval_copy_ctor_func(expr);
}
More fixes for array/object casts with temporary variables
2014-10-13 13:19:23 +00:00
} else {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
}
}
} else {
ZVAL_COPY_VALUE(result, expr);
More fixes for array/object casts with temporary variables
2014-10-13 13:19:23 +00:00
zval_opt_copy_ctor(result);
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
convert_to_object(result);
}
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
More fixes for array/object casts with temporary variables
2014-10-13 13:19:23 +00:00
Optimize ZEND_CAST to avoid zval copies The scalar type casts IS_NULL, IS_BOOL, IS_LONG, IS_DOUBLE and IS_STRING will no longer require a copy when casting. A copy is now only made when casting to IS_ARRAY and IS_OBJECT, if the type doesn't already match. I tweaked the reference handling for the type-already-correct case to DEREF the zval after that check. References require a copy anyway, so they can go through the slow codepath.
2014-04-25 13:21:26 +00:00
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_op_array *new_op_array=NULL;
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *inc_filename;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval tmp_inc_filename;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_bool failure_retval=0;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
inc_filename = GET_OP1_ZVAL_PTR(BP_VAR_R);
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_UNDEF(&tmp_inc_filename);
Changed data layout to allow more efficient operations
2014-04-02 10:34:44 +00:00
if (Z_TYPE_P(inc_filename) != IS_STRING) {
Fix bug #68133 and bug #68135
2014-10-03 19:06:26 +00:00
ZVAL_STR(&tmp_inc_filename, zval_get_string(inc_filename));
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
inc_filename = &tmp_inc_filename;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
master renames phase 1
2014-08-25 17:24:55 +00:00
if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename));
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
}
} else {
switch (opline->extended_value) {
case ZEND_INCLUDE_ONCE:
case ZEND_REQUIRE_ONCE: {
zend_file_handle file_handle;
Use zend_string* instead of char* for opened_patch handling. Avoid reallocations and improve string reuse.
2015-03-03 23:05:28 +00:00
zend_string *resolved_path;
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), (int)Z_STRLEN_P(inc_filename));
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
if (resolved_path) {
Use zend_string* instead of char* for opened_patch handling. Avoid reallocations and improve string reuse.
2015-03-03 23:05:28 +00:00
failure_retval = zend_hash_exists(&EG(included_files), resolved_path);
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
} else {
Use zend_string* instead of char* for opened_patch handling. Avoid reallocations and improve string reuse.
2015-03-03 23:05:28 +00:00
resolved_path = zend_string_copy(Z_STR_P(inc_filename));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
if (failure_retval) {
/* do nothing, file already included */
Use zend_string* instead of char* for opened_patch handling. Avoid reallocations and improve string reuse.
2015-03-03 23:05:28 +00:00
} else if (SUCCESS == zend_stream_open(resolved_path->val, &file_handle)) {
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
if (!file_handle.opened_path) {
Use zend_string* instead of char* for opened_patch handling. Avoid reallocations and improve string reuse.
2015-03-03 23:05:28 +00:00
file_handle.opened_path = zend_string_copy(resolved_path);
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
}
Use zend_string* instead of char* for opened_patch handling. Avoid reallocations and improve string reuse.
2015-03-03 23:05:28 +00:00
if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE));
zend_destroy_file_handle(&file_handle);
Fixed include_once() handling
2014-02-21 13:23:13 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_file_handle_dtor(&file_handle);
Fixed include_once() handling
2014-02-21 13:23:13 +00:00
failure_retval=1;
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
if (opline->extended_value == ZEND_INCLUDE_ONCE) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename));
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Use zend_string* instead of char* for opened_patch handling. Avoid reallocations and improve string reuse.
2015-03-03 23:05:28 +00:00
zend_string_release(resolved_path);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
break;
case ZEND_INCLUDE:
case ZEND_REQUIRE:
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
new_op_array = compile_filename(opline->extended_value, inc_filename);
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
break;
case ZEND_EVAL: {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
char *eval_desc = zend_make_compiled_string_description("eval()'d code");
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
new_op_array = zend_compile_string(inc_filename, eval_desc);
- Added new parameter parsing option (p - for valid path (string without null byte in the middle)) # The tests will be fixed in the next commits
2011-06-06 21:28:16 +00:00
efree(eval_desc);
}
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) {
Use specialized destructors when types of zvals are known.
2014-11-24 22:22:59 +00:00
zend_string_release(Z_STR(tmp_inc_filename));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
} else if (EXPECTED(new_op_array != NULL)) {
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
zval *return_value = NULL;
Simplify call-frame handling
2014-07-07 11:50:44 +00:00
zend_execute_data *call;
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (RETURN_VALUE_USED(opline)) {
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
return_value = EX_VAR(opline->result.var);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Get rid of EX(scope). In most cases we use EG(scope) anyway. EX(scope) was used to switch EG(scope) back after call, but it's possibleto use EX(func)->common.scope instead.
2014-11-28 07:21:18 +00:00
new_op_array->scope = EG(scope); /* ??? */
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE,
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
(zend_function*)new_op_array, 0, EX(called_scope), Z_OBJ(EX(This)), NULL);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Removed EG(active_symbol_table) and use corresponding value from EG(current_execute_data)
2014-07-04 14:03:45 +00:00
if (EX(symbol_table)) {
Simplify call-frame handling
2014-07-07 11:50:44 +00:00
call->symbol_table = EX(symbol_table);
Removed EG(active_symbol_table) and use corresponding value from EG(current_execute_data)
2014-07-04 14:03:45 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
call->symbol_table = zend_rebuild_symbol_table();
Lazy EG(active_symbol_table) initialization
2008-04-29 08:15:20 +00:00
}
Simplify call-frame handling
2014-07-07 11:50:44 +00:00
call->prev_execute_data = execute_data;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
i_init_code_execute_data(call, new_op_array, return_value);
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
if (EXPECTED(zend_execute_ex == execute_ex)) {
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
ZEND_VM_ENTER();
} else {
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_execute_ex(call);
- Removed direct executor recursion. - Use fastcall calling convention in executor on x86.
2008-06-11 13:18:41 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
destroy_op_array(new_op_array);
Use efree_size() instead of efree() where posible
2014-08-27 16:49:56 +00:00
efree_size(new_op_array, sizeof(zend_op_array));
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_throw_exception_internal(NULL);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
HANDLE_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
} else if (RETURN_VALUE_USED(opline)) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
improved timeout handling on windows
2015-03-16 16:48:29 +00:00
ZEND_VM_INTERRUPT_CHECK();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zval tmp, *varname;
HashTable *target_symbol_table;
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Additional specialization
2010-07-27 09:50:35 +00:00
if (OP1_TYPE == IS_CV &&
OP2_TYPE == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
Optimized unset()
2014-09-22 10:41:44 +00:00
zval *var = EX_VAR(opline->op1.var);
if (Z_REFCOUNTED_P(var)) {
zend_refcounted *garbage = Z_COUNTED_P(var);
if (!--GC_REFCOUNT(garbage)) {
ZVAL_UNDEF(var);
_zval_dtor_func_for_ptr(garbage ZEND_FILE_LINE_CC);
} else {
GC_ZVAL_CHECK_POSSIBLE_ROOT(var);
ZVAL_UNDEF(var);
}
} else {
ZVAL_UNDEF(var);
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
Lazy EG(active_symbol_table) initialization
2008-04-29 08:15:20 +00:00
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
Optimized unset()
2014-09-22 10:41:44 +00:00
ZVAL_UNDEF(&tmp);
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
Fix isset/unset on by-ref names as well
2014-10-06 16:56:23 +00:00
ZVAL_STR(&tmp, zval_get_string(varname));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
varname = &tmp;
}
Optimized access to static properties using executor specialization. A constant class name may be used as a direct operand of ZEND_FETCH_* instruction without previous ZEND_FETCH_CLASS.
2010-05-06 10:27:35 +00:00
if (OP2_TYPE != IS_UNUSED) {
zend_class_entry *ce;
if (OP2_TYPE == IS_CONST) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) {
ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0);
Fixed bug #65254 (Exception not catchable when exception thrown in autoload with a namespace).
2013-07-14 03:47:06 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
Use specialized destructors when types of zvals are known.
2014-11-24 22:22:59 +00:00
if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
zend_string_release(Z_STR(tmp));
Fixed bug #61011 (Crash when an exception is thrown by __autoload accessing a static property)
2012-02-25 13:56:59 +00:00
}
FREE_OP1();
Fixed bug #65254 (Exception not catchable when exception thrown in autoload with a namespace).
2013-07-14 03:47:06 +00:00
HANDLE_EXCEPTION();
}
if (UNEXPECTED(ce == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2)));
if (OP1_TYPE != IS_CONST) {
zend_string_release(Z_STR(tmp));
}
HANDLE_EXCEPTION();
Fixed bug #61011 (Crash when an exception is thrown by __autoload accessing a static property)
2012-02-25 13:56:59 +00:00
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
Optimized access to static properties using executor specialization. A constant class name may be used as a direct operand of ZEND_FETCH_* instruction without previous ZEND_FETCH_CLASS.
2010-05-06 10:27:35 +00:00
} else {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ce = Z_CE_P(EX_VAR(opline->op2.var));
Optimized access to static properties using executor specialization. A constant class name may be used as a direct operand of ZEND_FETCH_* instruction without previous ZEND_FETCH_CLASS.
2010-05-06 10:27:35 +00:00
}
Handle run-time cache for static properties directly in executor. Removed cache_slot argument in zend_std_get_static_property() and zend_std_unset_static_property().
2015-01-13 06:33:15 +00:00
zend_std_unset_static_property(ce, Z_STR_P(varname));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Use specialized destructors when types of zvals are known.
2014-11-24 22:22:59 +00:00
if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
zend_string_release(Z_STR(tmp));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1, free_op2;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *container;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *offset;
master renames phase 1
2014-08-25 17:24:55 +00:00
zend_ulong hval;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot unset string offsets");
FREE_UNFETCHED_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
fix UMR when variable name is an object and __toString is used # zend_call_function checks IS_REF on This
2011-03-16 05:25:02 +00:00
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
ZEND_VM_C_LABEL(unset_dim_again):
Improved specialisation $this variable accessed through IS_UNUSED operand must be IS_OBJECT, so we don't have to check for its type or perform dereference.
2014-10-10 12:36:12 +00:00
if (OP1_TYPE != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
HashTable *ht;
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
ZEND_VM_C_LABEL(offset_again):
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
SEPARATE_ARRAY(container);
ht = Z_ARRVAL_P(container);
Improved specialisation $this variable accessed through IS_UNUSED operand must be IS_OBJECT, so we don't have to check for its type or perform dereference.
2014-10-10 12:36:12 +00:00
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
hval = zend_dval_to_lval(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
case IS_LONG:
hval = Z_LVAL_P(offset);
Split IS_BOOL into IS_FALSE and IS_TRUE
2014-04-30 14:32:42 +00:00
ZEND_VM_C_LABEL(num_index_dim):
Improved specialisation $this variable accessed through IS_UNUSED operand must be IS_OBJECT, so we don't have to check for its type or perform dereference.
2014-10-10 12:36:12 +00:00
zend_hash_index_del(ht, hval);
break;
case IS_STRING:
if (OP2_TYPE != IS_CONST) {
if (ZEND_HANDLE_NUMERIC(Z_STR_P(offset), hval)) {
ZEND_VM_C_GOTO(num_index_dim);
Refactored IS_INDIRECT IS_VAR passing between opcodes to avoid reference counting
2014-04-04 15:01:53 +00:00
}
Improved specialisation $this variable accessed through IS_UNUSED operand must be IS_OBJECT, so we don't have to check for its type or perform dereference.
2014-10-10 12:36:12 +00:00
}
Merged zend_array and HashTable into the single data structure. Now each HashTable is also zend_array, so it's refcounted and may be a subject for Copy on Write zend_array_dup() was changed to allocate and return HashTable, instead of taking preallocated HashTable as argument.
2015-02-13 19:20:39 +00:00
if (ht == &EG(symbol_table)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_delete_global_variable(Z_STR_P(offset));
Improved specialisation $this variable accessed through IS_UNUSED operand must be IS_OBJECT, so we don't have to check for its type or perform dereference.
2014-10-10 12:36:12 +00:00
} else {
zend_hash_del(ht, Z_STR_P(offset));
}
break;
case IS_NULL:
zend_hash_del(ht, STR_EMPTY_ALLOC());
break;
case IS_FALSE:
hval = 0;
ZEND_VM_C_GOTO(num_index_dim);
case IS_TRUE:
hval = 1;
ZEND_VM_C_GOTO(num_index_dim);
case IS_RESOURCE:
hval = Z_RES_HANDLE_P(offset);
ZEND_VM_C_GOTO(num_index_dim);
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
ZEND_VM_C_GOTO(offset_again);
break;
default:
zend_error(E_WARNING, "Illegal offset type in unset");
break;
ZEND_UNSET_DIM_OBJ is splitted to ZEND_UNSET_DIM and ZEND_UNSET_OBJ.
2005-06-16 12:17:39 +00:00
}
Improved specialisation $this variable accessed through IS_UNUSED operand must be IS_OBJECT, so we don't have to check for its type or perform dereference.
2014-10-10 12:36:12 +00:00
} else if (OP1_TYPE == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot use object as array");
} else {
Improved specialisation $this variable accessed through IS_UNUSED operand must be IS_OBJECT, so we don't have to check for its type or perform dereference.
2014-10-10 12:36:12 +00:00
//??? if (OP2_TYPE == IS_CONST) {
//??? zval_copy_ctor(offset);
//??? }
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
Z_OBJ_HT_P(container)->unset_dimension(container, offset);
}
Improved ASSIGN_<OP>, ASSIGN_DIM and UNSET_DIM
2014-12-09 12:15:24 +00:00
} else if (OP1_TYPE != IS_UNUSED && Z_ISREF_P(container)) {
container = Z_REFVAL_P(container);
ZEND_VM_C_GOTO(unset_dim_again);
} else if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot unset string offsets");
ZEND_UNSET_DIM_OBJ is splitted to ZEND_UNSET_DIM and ZEND_UNSET_OBJ.
2005-06-16 12:17:39 +00:00
}
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
FREE_OP2();
ZEND_UNSET_DIM_OBJ is splitted to ZEND_UNSET_DIM and ZEND_UNSET_OBJ.
2005-06-16 12:17:39 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
ZEND_UNSET_DIM_OBJ is splitted to ZEND_UNSET_DIM and ZEND_UNSET_OBJ.
2005-06-16 12:17:39 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
ZEND_UNSET_DIM_OBJ is splitted to ZEND_UNSET_DIM and ZEND_UNSET_OBJ.
2005-06-16 12:17:39 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
ZEND_UNSET_DIM_OBJ is splitted to ZEND_UNSET_DIM and ZEND_UNSET_OBJ.
2005-06-16 12:17:39 +00:00
zend_free_op free_op1, free_op2;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *container;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *offset;
SAVE_OPLINE();
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot unset string offsets");
FREE_UNFETCHED_OP2();
FREE_OP1_VAR_PTR();
HANDLE_EXCEPTION();
Refactored IS_INDIRECT IS_VAR passing between opcodes to avoid reference counting
2014-04-04 15:01:53 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
ZEND_UNSET_DIM_OBJ is splitted to ZEND_UNSET_DIM and ZEND_UNSET_OBJ.
2005-06-16 12:17:39 +00:00
trailing whitespace removal
2015-01-03 09:22:58 +00:00
do {
Move checks for references into slow paths.
2014-12-08 22:09:44 +00:00
if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
if (Z_ISREF_P(container)) {
container = Z_REFVAL_P(container);
if (Z_TYPE_P(container) != IS_OBJECT) {
break;
}
} else {
break;
}
}
Refactored IS_INDIRECT IS_VAR passing between opcodes to avoid reference counting
2014-04-04 15:01:53 +00:00
if (Z_OBJ_HT_P(container)->unset_property) {
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
Z_OBJ_HT_P(container)->unset_property(container, offset, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
ZEND_UNSET_DIM_OBJ is splitted to ZEND_UNSET_DIM and ZEND_UNSET_OBJ.
2005-06-16 12:17:39 +00:00
} else {
Refactored IS_INDIRECT IS_VAR passing between opcodes to avoid reference counting
2014-04-04 15:01:53 +00:00
zend_error(E_NOTICE, "Trying to unset property of non-object");
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths.
2014-12-08 22:09:44 +00:00
} while (0);
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1_VAR_PTR();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZEND_VM_HANDLER(77, ZEND_FE_RESET_R, CONST|TMP|VAR|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
zval *array_ptr, *result;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
HashTable *fe_ht;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
array_ptr = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
result = EX_VAR(opline->result.var);
ZVAL_COPY_VALUE(result, array_ptr);
if (OP1_TYPE != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
Z_ADDREF_P(array_ptr);
}
Z_FE_POS_P(result) = 0;
FREE_OP1_IF_VAR();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
} else if (OP1_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
if (!Z_OBJCE_P(array_ptr)->get_iterator) {
HashPosition pos = 0;
Bucket *p;
result = EX_VAR(opline->result.var);
ZVAL_COPY_VALUE(result, array_ptr);
if (OP1_TYPE != IS_TMP_VAR) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
Z_ADDREF_P(array_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
fe_ht = Z_OBJPROP_P(array_ptr);
pos = 0;
while (1) {
if (pos >= fe_ht->nNumUsed) {
FREE_OP1_IF_VAR();
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
}
p = fe_ht->arData + pos;
if ((Z_TYPE(p->val) != IS_UNDEF &&
(Z_TYPE(p->val) != IS_INDIRECT ||
Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF)) &&
(!p->key ||
zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS)) {
break;
}
pos++;
}
Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(fe_ht, pos);
FREE_OP1_IF_VAR();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
zend_class_entry *ce = Z_OBJCE_P(array_ptr);
zend_object_iterator *iter = ce->get_iterator(ce, array_ptr, 0);
zend_bool is_empty;
if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
FREE_OP1();
if (!EG(exception)) {
zend_throw_exception_ex(NULL, 0, "Object of type %s did not create an Iterator", ce->name->val);
Fixed bug #49269 (Ternary operator fails on Iterator object when used inside foreach declaration). (Etienne, Dmitry)
2009-08-17 07:40:43 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
zend_throw_exception_internal(NULL);
HANDLE_EXCEPTION();
Fixed bug #49269 (Ternary operator fails on Iterator object when used inside foreach declaration). (Etienne, Dmitry)
2009-08-17 07:40:43 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
iter->index = 0;
if (iter->funcs->rewind) {
iter->funcs->rewind(iter);
if (UNEXPECTED(EG(exception) != NULL)) {
OBJ_RELEASE(&iter->std);
FREE_OP1();
HANDLE_EXCEPTION();
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
}
Fixed bug #39017 (foreach(($obj = new myClass) as $v); echo $obj; segfaults)
2006-10-03 09:05:14 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
is_empty = iter->funcs->valid(iter) != SUCCESS;
if (UNEXPECTED(EG(exception) != NULL)) {
OBJ_RELEASE(&iter->std);
FREE_OP1();
HANDLE_EXCEPTION();
}
iter->index = -1; /* will be set to 0 before using next handler */
ZVAL_OBJ(EX_VAR(opline->result.var), &iter->std);
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
FREE_OP1();
if (is_empty) {
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
Introduced immutable arrays. They don't need to be copyed and may be used directly from SHM.
2014-05-29 14:21:56 +00:00
} else {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
} else {
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
ZVAL_UNDEF(EX_VAR(opline->result.var));
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
FREE_OP1();
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZEND_VM_HANDLER(125, ZEND_FE_RESET_RW, CONST|TMP|VAR|CV, ANY)
{
USE_OPLINE
zend_free_op free_op1;
zval *array_ptr, *array_ref;
HashTable *fe_ht;
HashPosition pos = 0;
Bucket *p;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
SAVE_OPLINE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
array_ref = array_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
if (Z_ISREF_P(array_ref)) {
array_ptr = Z_REFVAL_P(array_ref);
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
} else {
array_ref = array_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
}
if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
if (array_ptr == array_ref) {
ZVAL_NEW_REF(array_ref, array_ref);
array_ptr = Z_REFVAL_P(array_ref);
}
Z_ADDREF_P(array_ref);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
array_ptr = EX_VAR(opline->result.var);
ZVAL_COPY_VALUE(array_ptr, array_ref);
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (OP1_TYPE == IS_CONST) {
zval_copy_ctor_func(array_ptr);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
SEPARATE_ARRAY(array_ptr);
}
fe_ht = Z_ARRVAL_P(array_ptr);
while (1) {
if (pos >= fe_ht->nNumUsed) {
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP1_VAR_PTR();
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
p = fe_ht->arData + pos;
if (Z_TYPE(p->val) != IS_UNDEF &&
(Z_TYPE(p->val) != IS_INDIRECT ||
Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF)) {
break;
- Bugfix #26229 (getIterator() segfaults when it returns arrays or scalars)
2005-01-25 10:40:51 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
pos++;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(fe_ht, pos);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
FREE_OP1_VAR_PTR();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
} else if (OP1_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
if (!Z_OBJCE_P(array_ptr)->get_iterator) {
if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
if (array_ptr == array_ref) {
ZVAL_NEW_REF(array_ref, array_ref);
array_ptr = Z_REFVAL_P(array_ref);
}
Z_ADDREF_P(array_ref);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
} else {
array_ptr = EX_VAR(opline->result.var);
ZVAL_COPY_VALUE(array_ptr, array_ref);
}
fe_ht = Z_OBJPROP_P(array_ptr);
while (1) {
if (pos >= fe_ht->nNumUsed) {
FREE_OP1_VAR_PTR();
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
}
p = fe_ht->arData + pos;
if ((Z_TYPE(p->val) != IS_UNDEF &&
(Z_TYPE(p->val) != IS_INDIRECT ||
Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF)) &&
(!p->key ||
zend_check_property_access(Z_OBJ_P(array_ptr), p->key) == SUCCESS)) {
break;
}
pos++;
}
Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(fe_ht, pos);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
FREE_OP1_VAR_PTR();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
} else {
zend_class_entry *ce = Z_OBJCE_P(array_ptr);
zend_object_iterator *iter = ce->get_iterator(ce, array_ptr, 1);
zend_bool is_empty;
if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
if (OP1_TYPE == IS_VAR) {
FREE_OP1_VAR_PTR();
} else {
FREE_OP1();
}
if (!EG(exception)) {
zend_throw_exception_ex(NULL, 0, "Object of type %s did not create an Iterator", ce->name->val);
}
zend_throw_exception_internal(NULL);
HANDLE_EXCEPTION();
}
iter->index = 0;
if (iter->funcs->rewind) {
iter->funcs->rewind(iter);
if (UNEXPECTED(EG(exception) != NULL)) {
OBJ_RELEASE(&iter->std);
if (OP1_TYPE == IS_VAR) {
FREE_OP1_VAR_PTR();
} else {
FREE_OP1();
}
HANDLE_EXCEPTION();
}
}
is_empty = iter->funcs->valid(iter) != SUCCESS;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
OBJ_RELEASE(&iter->std);
if (OP1_TYPE == IS_VAR) {
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP1_VAR_PTR();
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
} else {
FREE_OP1();
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
HANDLE_EXCEPTION();
Fixed bug #32674 (exception in iterator causes crash)
2005-04-27 06:47:08 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
iter->index = -1; /* will be set to 0 before using next handler */
ZVAL_OBJ(EX_VAR(opline->result.var), &iter->std);
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
if (OP1_TYPE == IS_VAR) {
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP1_VAR_PTR();
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
} else {
FREE_OP1();
}
if (is_empty) {
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
} else {
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
}
Fixed bug #32674 (exception in iterator causes crash)
2005-04-27 06:47:08 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
} else {
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
ZVAL_UNDEF(EX_VAR(opline->result.var));
Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
if (OP1_TYPE == IS_VAR) {
FREE_OP1_VAR_PTR();
} else {
FREE_OP1();
}
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
}
}
ZEND_VM_HANDLER(78, ZEND_FE_FETCH_R, VAR, ANY)
{
USE_OPLINE
zval *array;
zval *value;
HashTable *fe_ht;
HashPosition pos;
Bucket *p;
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
array = EX_VAR(opline->op1.var);
SAVE_OPLINE();
if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
fe_ht = Z_ARRVAL_P(array);
pos = Z_FE_POS_P(EX_VAR(opline->op1.var));
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
while (1) {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
/* reached end of iteration */
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
- Cleanup foreach statement
2005-02-05 14:01:59 +00:00
}
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
p = fe_ht->arData + pos;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
value = &p->val;
if (Z_TYPE_P(value) == IS_UNDEF) {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
pos++;
continue;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
} else if (Z_TYPE_P(value) == IS_INDIRECT) {
value = Z_INDIRECT_P(value);
if (Z_TYPE_P(value) == IS_UNDEF) {
pos++;
continue;
}
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
break;
}
if (opline->extended_value) {
if (!p->key) {
ZVAL_LONG(EX_VAR((opline+1)->result.var), p->h);
} else {
ZVAL_STR_COPY(EX_VAR((opline+1)->result.var), p->key);
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
}
- Cleanup foreach statement
2005-02-05 14:01:59 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZVAL_COPY(EX_VAR(opline->result.var), value);
Z_FE_POS_P(EX_VAR(opline->op1.var)) = pos + 1;
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
zend_object_iterator *iter;
if ((iter = zend_iterator_unwrap(array)) == NULL) {
/* plain object */
fe_ht = Z_OBJPROP_P(array);
pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
while (1) {
if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
/* reached end of iteration */
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
}
p = fe_ht->arData + pos;
value = &p->val;
if (Z_TYPE_P(value) == IS_UNDEF) {
pos++;
continue;
} else if (Z_TYPE_P(value) == IS_INDIRECT) {
value = Z_INDIRECT_P(value);
if (Z_TYPE_P(value) == IS_UNDEF) {
pos++;
continue;
}
}
if (!p->key ||
zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS) {
break;
}
pos++;
}
if (opline->extended_value) {
if (UNEXPECTED(!p->key)) {
ZVAL_LONG(EX_VAR((opline+1)->result.var), p->h);
} else if (p->key->val[0]) {
ZVAL_STR_COPY(EX_VAR((opline+1)->result.var), p->key);
} else {
const char *class_name, *prop_name;
size_t prop_name_len;
zend_unmangle_property_name_ex(
p->key, &class_name, &prop_name, &prop_name_len);
ZVAL_STRINGL(EX_VAR((opline+1)->result.var), prop_name, prop_name_len);
}
}
ZVAL_COPY(EX_VAR(opline->result.var), value);
while (1) {
pos++;
if (pos >= fe_ht->nNumUsed) {
Changed HashTable layout: Removed HashTable->arHash (reduced memory consumption). Now hash slots may be accessed using HT_HASH() macro. Hash slotas are allocated together with Buckets (before them) and lay in reverse order from HashTable->arData base address (see comments in Zend/zend_types.h) Indexes in hash table and conflict resolution chains (Z_NEXT) may be stored as indeces or offsets in bytes, depending on system (32 or 64-bit). HashTable data filelds are reordered to keep the most useful for zend_hash_find() data in the same CPU cache line.
2015-03-13 14:13:19 +00:00
pos = HT_INVALID_IDX;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
break;
}
p = fe_ht->arData + pos;
if ((Z_TYPE(p->val) != IS_UNDEF &&
(Z_TYPE(p->val) != IS_INDIRECT ||
Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF)) &&
(Z_TYPE_P(array) != IS_OBJECT ||
!p->key ||
zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS)) {
break;
}
}
Stop using internal array/object pointer in foreach by reference according to https://wiki.php.net/rfc/php7_foreach
2015-02-12 11:36:04 +00:00
EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
} else {
/* !iter happens from exception */
if (iter && ++iter->index > 0) {
/* This could cause an endless loop if index becomes zero again.
* In case that ever happens we need an additional flag. */
iter->funcs->move_forward(iter);
if (UNEXPECTED(EG(exception) != NULL)) {
zval_ptr_dtor(array);
HANDLE_EXCEPTION();
}
}
/* If index is zero we come from FE_RESET and checked valid() already. */
if (!iter || (iter->index > 0 && iter->funcs->valid(iter) == FAILURE)) {
/* reached end of iteration */
if (UNEXPECTED(EG(exception) != NULL)) {
zval_ptr_dtor(array);
HANDLE_EXCEPTION();
}
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
}
value = iter->funcs->get_current_data(iter);
if (UNEXPECTED(EG(exception) != NULL)) {
zval_ptr_dtor(array);
HANDLE_EXCEPTION();
}
if (!value) {
/* failure in get_current_data */
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
}
ZVAL_COPY(EX_VAR(opline->result.var), value);
if (opline->extended_value) {
if (iter->funcs->get_current_key) {
iter->funcs->get_current_key(iter, EX_VAR((opline+1)->result.var));
if (UNEXPECTED(EG(exception) != NULL)) {
zval_ptr_dtor(array);
HANDLE_EXCEPTION();
}
} else {
ZVAL_LONG(EX_VAR((opline+1)->result.var), iter->index);
}
}
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
- Cleanup foreach statement
2005-02-05 14:01:59 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
zval *array;
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *value;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
HashTable *fe_ht;
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
HashPosition pos;
Bucket *p;
Fixed "foreach ($reference as $val)"
2014-03-05 19:22:50 +00:00
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
array = EX_VAR(opline->op1.var);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZVAL_DEREF(array);
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
fe_ht = Z_ARRVAL_P(array);
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
while (1) {
if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
/* reached end of iteration */
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
}
p = fe_ht->arData + pos;
value = &p->val;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (Z_TYPE_P(value) == IS_UNDEF) {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
pos++;
continue;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
} else if (Z_TYPE_P(value) == IS_INDIRECT) {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
value = Z_INDIRECT_P(value);
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (Z_TYPE_P(value) == IS_UNDEF) {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
pos++;
continue;
}
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
break;
}
if (opline->extended_value) {
if (!p->key) {
ZVAL_LONG(EX_VAR((opline+1)->result.var), p->h);
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
} else {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZVAL_STR_COPY(EX_VAR((opline+1)->result.var), p->key);
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
}
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZVAL_MAKE_REF(value);
Z_ADDREF_P(value);
ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(value));
while (1) {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
pos++;
if (pos >= fe_ht->nNumUsed) {
Changed HashTable layout: Removed HashTable->arHash (reduced memory consumption). Now hash slots may be accessed using HT_HASH() macro. Hash slotas are allocated together with Buckets (before them) and lay in reverse order from HashTable->arData base address (see comments in Zend/zend_types.h) Indexes in hash table and conflict resolution chains (Z_NEXT) may be stored as indeces or offsets in bytes, depending on system (32 or 64-bit). HashTable data filelds are reordered to keep the most useful for zend_hash_find() data in the same CPU cache line.
2015-03-13 14:13:19 +00:00
pos = HT_INVALID_IDX;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
break;
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
}
p = fe_ht->arData + pos;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (Z_TYPE(p->val) != IS_UNDEF &&
(Z_TYPE(p->val) != IS_INDIRECT ||
Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF)) {
break;
}
}
Stop using internal array/object pointer in foreach by reference according to https://wiki.php.net/rfc/php7_foreach
2015-02-12 11:36:04 +00:00
EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
zend_object_iterator *iter;
trailing whitespace removal
2015-01-03 09:22:58 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if ((iter = zend_iterator_unwrap(array)) == NULL) {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
/* plain object */
trailing whitespace removal
2015-01-03 09:22:58 +00:00
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
fe_ht = Z_OBJPROP_P(array);
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
while (1) {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* reached end of iteration */
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
p = fe_ht->arData + pos;
value = &p->val;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (Z_TYPE_P(value) == IS_UNDEF) {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
pos++;
continue;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
} else if (Z_TYPE_P(value) == IS_INDIRECT) {
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
value = Z_INDIRECT_P(value);
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (Z_TYPE_P(value) == IS_UNDEF) {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
pos++;
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
continue;
}
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (!p->key ||
zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS) {
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
break;
}
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
pos++;
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (opline->extended_value) {
if (UNEXPECTED(!p->key)) {
ZVAL_LONG(EX_VAR((opline+1)->result.var), p->h);
} else if (p->key->val[0]) {
ZVAL_STR_COPY(EX_VAR((opline+1)->result.var), p->key);
} else {
const char *class_name, *prop_name;
size_t prop_name_len;
zend_unmangle_property_name_ex(
p->key, &class_name, &prop_name, &prop_name_len);
ZVAL_STRINGL(EX_VAR((opline+1)->result.var), prop_name, prop_name_len);
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZVAL_MAKE_REF(value);
Z_ADDREF_P(value);
ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(value));
while (1) {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
pos++;
if (pos >= fe_ht->nNumUsed) {
Changed HashTable layout: Removed HashTable->arHash (reduced memory consumption). Now hash slots may be accessed using HT_HASH() macro. Hash slotas are allocated together with Buckets (before them) and lay in reverse order from HashTable->arData base address (see comments in Zend/zend_types.h) Indexes in hash table and conflict resolution chains (Z_NEXT) may be stored as indeces or offsets in bytes, depending on system (32 or 64-bit). HashTable data filelds are reordered to keep the most useful for zend_hash_find() data in the same CPU cache line.
2015-03-13 14:13:19 +00:00
pos = HT_INVALID_IDX;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
break;
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
}
p = fe_ht->arData + pos;
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if ((Z_TYPE(p->val) != IS_UNDEF &&
(Z_TYPE(p->val) != IS_INDIRECT ||
Z_TYPE_P(Z_INDIRECT(p->val)) != IS_UNDEF)) &&
(Z_TYPE_P(array) != IS_OBJECT ||
!p->key ||
zend_check_property_access(Z_OBJ_P(array), p->key) == SUCCESS)) {
break;
}
}
Stop using internal array/object pointer in foreach by reference according to https://wiki.php.net/rfc/php7_foreach
2015-02-12 11:36:04 +00:00
EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
} else {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* !iter happens from exception */
- MFH missing bits and pieces of the partial sync with head # This time i added: # ZEND_FE_RESET_VARIABLE # ZEND_FE_RESET_REFERENCE # and dapted parser,compiler,executor,interfaces to handle these flags # their purpose is to be able to pass whetehr foreach is done by ref to # the current() handler so that it can error out in case it is not capable # to comply to the requested return signature/protocol/semantics (weyp).
2006-05-11 21:07:39 +00:00
if (iter && ++iter->index > 0) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* This could cause an endless loop if index becomes zero again.
* In case that ever happens we need an additional flag. */
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
iter->funcs->move_forward(iter);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
zval_ptr_dtor(array);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
HANDLE_EXCEPTION();
Fixed bug #32674 (exception in iterator causes crash)
2005-04-27 06:47:08 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
- MFH missing bits and pieces of the partial sync with head # This time i added: # ZEND_FE_RESET_VARIABLE # ZEND_FE_RESET_REFERENCE # and dapted parser,compiler,executor,interfaces to handle these flags # their purpose is to be able to pass whetehr foreach is done by ref to # the current() handler so that it can error out in case it is not capable # to comply to the requested return signature/protocol/semantics (weyp).
2006-05-11 21:07:39 +00:00
/* If index is zero we come from FE_RESET and checked valid() already. */
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (!iter || (iter->index > 0 && iter->funcs->valid(iter) == FAILURE)) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* reached end of iteration */
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
zval_ptr_dtor(array);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
HANDLE_EXCEPTION();
Fixed bug #32674 (exception in iterator causes crash)
2005-04-27 06:47:08 +00:00
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
value = iter->funcs->get_current_data(iter);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
zval_ptr_dtor(array);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
HANDLE_EXCEPTION();
Fixed bug #32993 (implemented Iterator function current() don't throw exception)
2005-06-06 08:24:05 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (!value) {
/* failure in get_current_data */
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
if (opline->extended_value) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (iter->funcs->get_current_key) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
iter->funcs->get_current_key(iter, EX_VAR((opline+1)->result.var));
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
if (UNEXPECTED(EG(exception) != NULL)) {
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
zval_ptr_dtor(array);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
HANDLE_EXCEPTION();
Fixed bug #32674 (exception in iterator causes crash)
2005-04-27 06:47:08 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
ZVAL_LONG(EX_VAR((opline+1)->result.var), iter->index);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
ZVAL_MAKE_REF(value);
Z_ADDREF_P(value);
ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(value));
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
} else {
Optimized FE_RESET and FE_FETCH
2014-09-15 21:34:27 +00:00
zend_error(E_WARNING, "Invalid argument supplied for foreach()");
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
foreash($a as $key => $val) optimization Removed temorary array creation on each iteration.
2005-02-07 16:09:54 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *value;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Additional specialization
2010-07-27 09:50:35 +00:00
if (OP1_TYPE == IS_CV &&
OP2_TYPE == IS_UNUSED &&
(opline->extended_value & ZEND_QUICK_SET)) {
Micro optimizations for isset/empty
2014-10-16 20:17:13 +00:00
value = EX_VAR(opline->op1.var);
trailing whitespace removal
2015-01-03 09:22:58 +00:00
if (opline->extended_value & ZEND_ISSET) {
Micro optimizations for isset/empty
2014-10-16 20:17:13 +00:00
ZVAL_BOOL(EX_VAR(opline->result.var),
Z_TYPE_P(value) > IS_NULL &&
(!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL));
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
ZVAL_BOOL(EX_VAR(opline->result.var),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
!i_zend_is_true(value));
Micro optimizations for isset/empty
2014-10-16 20:17:13 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Micro optimizations for isset/empty
2014-10-16 20:17:13 +00:00
ZEND_VM_NEXT_OPCODE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
Lazy EG(active_symbol_table) initialization
2008-04-29 08:15:20 +00:00
zend_free_op free_op1;
zval tmp, *varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
Use specialized destructors when types of zvals are known.
2014-11-24 22:22:59 +00:00
ZVAL_UNDEF(&tmp);
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
Fix isset/unset on by-ref names as well
2014-10-06 16:56:23 +00:00
ZVAL_STR(&tmp, zval_get_string(varname));
Lazy EG(active_symbol_table) initialization
2008-04-29 08:15:20 +00:00
varname = &tmp;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Lazy EG(active_symbol_table) initialization
2008-04-29 08:15:20 +00:00
Optimized access to static properties using executor specialization. A constant class name may be used as a direct operand of ZEND_FETCH_* instruction without previous ZEND_FETCH_CLASS.
2010-05-06 10:27:35 +00:00
if (OP2_TYPE != IS_UNUSED) {
zend_class_entry *ce;
if (OP2_TYPE == IS_CONST) {
Handle run-time cache for static properties directly in executor. Removed cache_slot argument in zend_std_get_static_property() and zend_std_unset_static_property().
2015-01-13 06:33:15 +00:00
if (OP1_TYPE == IS_CONST && CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) {
ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)));
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
value = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)) + sizeof(void*));
Handle run-time cache for static properties directly in executor. Removed cache_slot argument in zend_std_get_static_property() and zend_std_unset_static_property().
2015-01-13 06:33:15 +00:00
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name->val, Z_STR_P(varname));
}
ZEND_VM_C_GOTO(is_var_return);
} else if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0);
Fixed bug #61011 (Crash when an exception is thrown by __autoload accessing a static property)
2012-02-25 13:56:59 +00:00
if (UNEXPECTED(ce == NULL)) {
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
Optimized access to static properties using executor specialization. A constant class name may be used as a direct operand of ZEND_FETCH_* instruction without previous ZEND_FETCH_CLASS.
2010-05-06 10:27:35 +00:00
} else {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ce = Z_CE_P(EX_VAR(opline->op2.var));
Handle run-time cache for static properties directly in executor. Removed cache_slot argument in zend_std_get_static_property() and zend_std_unset_static_property().
2015-01-13 06:33:15 +00:00
if (OP1_TYPE == IS_CONST &&
(value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce)) != NULL) {
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name->val, Z_STR_P(varname));
}
ZEND_VM_C_GOTO(is_var_return);
}
Optimized access to static properties using executor specialization. A constant class name may be used as a direct operand of ZEND_FETCH_* instruction without previous ZEND_FETCH_CLASS.
2010-05-06 10:27:35 +00:00
}
Handle run-time cache for static properties directly in executor. Removed cache_slot argument in zend_std_get_static_property() and zend_std_unset_static_property().
2015-01-13 06:33:15 +00:00
value = zend_std_get_static_property(ce, Z_STR_P(varname), 1);
if (OP1_TYPE == IS_CONST && value) {
CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce, value);
}
Lazy EG(active_symbol_table) initialization
2008-04-29 08:15:20 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
Fix bug #68162: isset($$varname) always true
2014-10-06 18:38:05 +00:00
value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
Lazy EG(active_symbol_table) initialization
2008-04-29 08:15:20 +00:00
}
Use specialized destructors when types of zvals are known.
2014-11-24 22:22:59 +00:00
if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
zend_string_release(Z_STR(tmp));
Lazy EG(active_symbol_table) initialization
2008-04-29 08:15:20 +00:00
}
FREE_OP1();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Handle run-time cache for static properties directly in executor. Removed cache_slot argument in zend_std_get_static_property() and zend_std_unset_static_property().
2015-01-13 06:33:15 +00:00
ZEND_VM_C_LABEL(is_var_return):
trailing whitespace removal
2015-01-03 09:22:58 +00:00
if (opline->extended_value & ZEND_ISSET) {
Micro optimizations for isset/empty
2014-10-16 20:17:13 +00:00
ZVAL_BOOL(EX_VAR(opline->result.var),
value && Z_TYPE_P(value) > IS_NULL &&
(!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL));
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
ZVAL_BOOL(EX_VAR(opline->result.var),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
!value || !i_zend_is_true(value));
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Micro optimizations for isset/empty
2014-10-16 20:17:13 +00:00
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, CONST|TMPVAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Simplified string offset reading
2010-07-16 11:44:30 +00:00
zend_free_op free_op1, free_op2;
Use zval* instead of zval**
2013-10-28 10:44:07 +00:00
zval *container;
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
int result;
master renames phase 1
2014-08-25 17:24:55 +00:00
zend_ulong hval;
Simplified string offset reading
2010-07-16 11:44:30 +00:00
zval *offset;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
Simplified string offset reading
2010-07-16 11:44:30 +00:00
offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
Fixed memory allocation bugs related to magic object handlers (__get(), __set(), ...)
2005-06-03 11:16:19 +00:00
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_C_LABEL(isset_dim_obj_again):
Micro optimizations for isset/empty
2014-10-16 20:17:13 +00:00
if (OP1_TYPE != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
HashTable *ht = Z_ARRVAL_P(container);
Simplify code
2014-06-05 14:42:17 +00:00
zval *value;
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
zend_string *str;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing
2014-03-26 14:07:31 +00:00
ZEND_VM_C_LABEL(isset_again):
Simplify code
2014-06-05 14:42:17 +00:00
if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
str = Z_STR_P(offset);
if (OP2_TYPE != IS_CONST) {
if (ZEND_HANDLE_NUMERIC(str, hval)) {
ZEND_VM_C_GOTO(num_index_prop);
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
}
Simplify code
2014-06-05 14:42:17 +00:00
}
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
ZEND_VM_C_LABEL(str_index_prop):
Simplify code
2014-06-05 14:42:17 +00:00
value = zend_hash_find_ind(ht, str);
master renames phase 1
2014-08-25 17:24:55 +00:00
} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
hval = Z_LVAL_P(offset);
Simplify code
2014-06-05 14:42:17 +00:00
ZEND_VM_C_LABEL(num_index_prop):
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
master renames phase 1
2014-08-25 17:24:55 +00:00
hval = zend_dval_to_lval(Z_DVAL_P(offset));
Simplify code
2014-06-05 14:42:17 +00:00
ZEND_VM_C_GOTO(num_index_prop);
case IS_NULL:
str = STR_EMPTY_ALLOC();
ZEND_VM_C_GOTO(str_index_prop);
case IS_FALSE:
hval = 0;
ZEND_VM_C_GOTO(num_index_prop);
case IS_TRUE:
fixed "isset($array[true]);"
2014-07-22 14:40:29 +00:00
hval = 1;
Simplify code
2014-06-05 14:42:17 +00:00
ZEND_VM_C_GOTO(num_index_prop);
case IS_RESOURCE:
hval = Z_RES_HANDLE_P(offset);
ZEND_VM_C_GOTO(num_index_prop);
case IS_REFERENCE:
offset = Z_REFVAL_P(offset);
ZEND_VM_C_GOTO(isset_again);
default:
zend_error(E_WARNING, "Illegal offset type in isset or empty");
value = NULL;
break;
}
Simplified string offset reading
2010-07-16 11:44:30 +00:00
}
if (opline->extended_value & ZEND_ISSET) {
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
/* > IS_NULL means not IS_UNDEF and not IS_NULL */
Fixed support for references
2014-08-14 18:44:25 +00:00
result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
(!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
Simplified string offset reading
2010-07-16 11:44:30 +00:00
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
result = (value == NULL || !i_zend_is_true(value));
Simplified string offset reading
2010-07-16 11:44:30 +00:00
}
Micro optimizations for isset/empty
2014-10-16 20:17:13 +00:00
} else if (OP1_TYPE == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
if (EXPECTED(Z_OBJ_HT_P(container)->has_dimension)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0);
Simplified string offset reading
2010-07-16 11:44:30 +00:00
} else {
zend_isset_isempty_dim_prop_obj_handler() split into separate handlers. (Actually, it shared near nothing)
2014-04-21 20:32:29 +00:00
zend_error(E_NOTICE, "Trying to check element of non-array");
result = 0;
Simplified string offset reading
2010-07-16 11:44:30 +00:00
}
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
if ((opline->extended_value & ZEND_ISSET) == 0) {
result = !result;
}
Micro optimizations for isset/empty
2014-10-16 20:17:13 +00:00
} else if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { /* string offsets */
Simplified string offset reading
2010-07-16 11:44:30 +00:00
zval tmp;
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
result = 0;
master renames phase 1
2014-08-25 17:24:55 +00:00
if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
Get rid of duplicate handlers (where the code for IS_TMP_VAR and IS_VAR operands is the same)
2014-12-05 09:40:47 +00:00
if (OP2_TYPE & (IS_CV|IS_VAR)) {
fixed support for references
2014-07-29 11:29:22 +00:00
ZVAL_DEREF(offset);
}
Handle interned strings as non-refcounted scalars
2014-03-05 09:55:56 +00:00
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
WS, merged from trunk cause this issue, sorry
2012-01-26 01:28:37 +00:00
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
master renames phase 1
2014-08-25 17:24:55 +00:00
&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_DUP(&tmp, offset);
master renames phase 7
2014-08-25 19:51:49 +00:00
convert_to_long(&tmp);
WS, merged from trunk cause this issue, sorry
2012-01-26 01:28:37 +00:00
offset = &tmp;
}
Simplified string offset reading
2010-07-16 11:44:30 +00:00
}
Micro optimizations for isset/empty
2014-10-16 20:17:13 +00:00
if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
redo the fix with cast to size_t
2014-09-16 11:22:00 +00:00
if (offset->value.lval >= 0 && (size_t)offset->value.lval < Z_STRLEN_P(container)) {
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
Simplified string offset reading
2010-07-16 11:44:30 +00:00
result = 1;
trailing whitespace removal
2015-01-03 09:22:58 +00:00
}
Simplified string offset reading
2010-07-16 11:44:30 +00:00
}
}
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
if ((opline->extended_value & ZEND_ISSET) == 0) {
result = !result;
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
} else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
container = Z_REFVAL_P(container);
ZEND_VM_C_GOTO(isset_dim_obj_again);
Simplified string offset reading
2010-07-16 11:44:30 +00:00
} else {
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
result = ((opline->extended_value & ZEND_ISSET) == 0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Cleanup (2-nd round)
2014-04-15 17:56:30 +00:00
FREE_OP2();
Optimized ISSET_ISEMPTY_DIM_OBJ
2014-04-07 10:56:34 +00:00
ZVAL_BOOL(EX_VAR(opline->result.var), result);
Support isset() on temporaries
2014-05-31 18:05:03 +00:00
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED|CV, CONST|TMPVAR|CV)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
zend_isset_isempty_dim_prop_obj_handler() split into separate handlers. (Actually, it shared near nothing)
2014-04-21 20:32:29 +00:00
USE_OPLINE
zend_free_op free_op1, free_op2;
zval *container;
int result;
zval *offset;
SAVE_OPLINE();
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
zend_isset_isempty_dim_prop_obj_handler() split into separate handlers. (Actually, it shared near nothing)
2014-04-21 20:32:29 +00:00
offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
container = Z_REFVAL_P(container);
if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
ZEND_VM_C_GOTO(isset_no_object);
}
zend_isset_isempty_dim_prop_obj_handler() split into separate handlers. (Actually, it shared near nothing)
2014-04-21 20:32:29 +00:00
} else {
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_C_GOTO(isset_no_object);
zend_isset_isempty_dim_prop_obj_handler() split into separate handlers. (Actually, it shared near nothing)
2014-04-21 20:32:29 +00:00
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
}
if (UNEXPECTED(!Z_OBJ_HT_P(container)->has_property)) {
zend_error(E_NOTICE, "Trying to check property of non-object");
ZEND_VM_C_LABEL(isset_no_object):
result = ((opline->extended_value & ZEND_ISSET) == 0);
} else {
Use cache_slot offsets instead of indexes (simplify run-time instructions)
2015-02-24 22:52:35 +00:00
result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
zend_isset_isempty_dim_prop_obj_handler() split into separate handlers. (Actually, it shared near nothing)
2014-04-21 20:32:29 +00:00
if ((opline->extended_value & ZEND_ISSET) == 0) {
result = !result;
}
}
FREE_OP2();
ZVAL_BOOL(EX_VAR(opline->result.var), result);
Support isset() on temporaries
2014-05-31 18:05:03 +00:00
FREE_OP1();
zend_isset_isempty_dim_prop_obj_handler() split into separate handlers. (Actually, it shared near nothing)
2014-04-21 20:32:29 +00:00
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMPVAR|UNUSED|CV, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Wrap "wrong" unreachable code with "#if 0"
2006-06-08 08:37:51 +00:00
#if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
SAVE_OPLINE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (OP1_TYPE != IS_UNUSED) {
zend_free_op free_op1;
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
zval *ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
do {
if (Z_TYPE_P(ptr) == IS_LONG) {
EG(exit_status) = Z_LVAL_P(ptr);
} else {
if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(ptr)) {
ptr = Z_REFVAL_P(ptr);
if (Z_TYPE_P(ptr) == IS_LONG) {
EG(exit_status) = Z_LVAL_P(ptr);
break;
trailing whitespace removal
2015-01-03 09:22:58 +00:00
}
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_print_variable(ptr);
Move checks for references into slow paths of handlers or helpers. Remove duplicate opcode handlers.
2014-12-08 15:11:14 +00:00
}
} while (0);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
}
- MFH Sync vm generation with head - Regenerate vm
2006-05-21 18:00:14 +00:00
#endif
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_bailout();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
ZEND_VM_NEXT_OPCODE(); /* Never reached */
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- MFH missing bits and pieces of the partial sync with head # This time i added: # ZEND_FE_RESET_VARIABLE # ZEND_FE_RESET_REFERENCE # and dapted parser,compiler,executor,interfaces to handle these flags # their purpose is to be able to pass whetehr foreach is done by ref to # the current() handler so that it can error out in case it is not capable # to comply to the requested return signature/protocol/semantics (weyp).
2006-05-11 21:07:39 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Simplify BEGIN_SILENCE/END_SILENCE to not modify ini entry value back and force
2014-09-03 11:17:50 +00:00
ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting));
- MFH missing bits and pieces of the partial sync with head # This time i added: # ZEND_FE_RESET_VARIABLE # ZEND_FE_RESET_REFERENCE # and dapted parser,compiler,executor,interfaces to handle these flags # their purpose is to be able to pass whetehr foreach is done by ref to # the current() handler so that it can error out in case it is not capable # to comply to the requested return signature/protocol/semantics (weyp).
2006-05-11 21:07:39 +00:00
Simplify BEGIN_SILENCE/END_SILENCE to not modify ini entry value back and force
2014-09-03 11:17:50 +00:00
if (EG(error_reporting)) {
do {
Avoid memory allocation/deallocation in BEGIN_SILENCE/END_SILENCE opcode handlers.
2014-09-02 18:13:24 +00:00
EG(error_reporting) = 0;
Simplify BEGIN_SILENCE/END_SILENCE to not modify ini entry value back and force
2014-09-03 11:17:50 +00:00
if (!EG(error_reporting_ini_entry)) {
zend_ini_entry *p = zend_hash_str_find_ptr(EG(ini_directives), "error_reporting", sizeof("error_reporting")-1);
if (p) {
EG(error_reporting_ini_entry) = p;
} else {
break;
}
}
improved performance of @ (silence) operator
2010-08-18 13:58:13 +00:00
if (!EG(error_reporting_ini_entry)->modified) {
if (!EG(modified_ini_directives)) {
ALLOC_HASHTABLE(EG(modified_ini_directives));
zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
if (EXPECTED(zend_hash_str_add_ptr(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting")-1, EG(error_reporting_ini_entry)) != NULL)) {
improved performance of @ (silence) operator
2010-08-18 13:58:13 +00:00
EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
EG(error_reporting_ini_entry)->modified = 1;
}
}
Simplify BEGIN_SILENCE/END_SILENCE to not modify ini entry value back and force
2014-09-03 11:17:50 +00:00
} while (0);
}
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Simplify BEGIN_SILENCE/END_SILENCE to not modify ini entry value back and force
2014-09-03 11:17:50 +00:00
if (!EG(error_reporting) && Z_LVAL_P(EX_VAR(opline->op1.var)) != 0) {
EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var));
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
- MFH Improved version of ternary shortcut (Marcus)
2007-11-21 09:41:35 +00:00
ZEND_VM_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- MFH Improved version of ternary shortcut (Marcus)
2007-11-21 09:41:35 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *value;
Fixed refcounting for references
2014-09-11 15:12:12 +00:00
int is_ref = 0;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed refcounting for references
2014-09-11 15:12:12 +00:00
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
Improved ternary operator performance when returning arrays
2011-10-18 19:42:42 +00:00
Fixed refcounting for references
2014-09-11 15:12:12 +00:00
if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && Z_ISREF_P(value)) {
is_ref = 1;
value = Z_REFVAL_P(value);
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (i_zend_is_true(value)) {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
if (OP1_TYPE == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
zval_copy_ctor_func(EX_VAR(opline->result.var));
Improved ternary operator performance when returning arrays
2011-10-18 19:42:42 +00:00
}
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
} else if (OP1_TYPE == IS_CV) {
if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
Fixed refcounting for references
2014-09-11 15:12:12 +00:00
} else if (OP1_TYPE == IS_VAR && is_ref) {
if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
FREE_OP1();
Improved ternary operator performance when returning arrays
2011-10-18 19:42:42 +00:00
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
- MFH Improved version of ternary shortcut (Marcus)
2007-11-21 09:41:35 +00:00
}
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- MFH Improved version of ternary shortcut (Marcus)
2007-11-21 09:41:35 +00:00
ZEND_VM_NEXT_OPCODE();
}
Initial coalesce operator implementation
2014-09-16 18:14:46 +00:00
ZEND_VM_HANDLER(169, ZEND_COALESCE, CONST|TMP|VAR|CV, ANY)
{
USE_OPLINE
zend_free_op free_op1;
zval *value;
int is_ref = 0;
SAVE_OPLINE();
value = GET_OP1_ZVAL_PTR(BP_VAR_IS);
if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && Z_ISREF_P(value)) {
is_ref = 1;
value = Z_REFVAL_P(value);
}
if (Z_TYPE_P(value) > IS_NULL) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
if (OP1_TYPE == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
zval_copy_ctor_func(EX_VAR(opline->result.var));
}
} else if (OP1_TYPE == IS_CV) {
if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
} else if (OP1_TYPE == IS_VAR && is_ref) {
if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
FREE_OP1();
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
Initial coalesce operator implementation
2014-09-16 18:14:46 +00:00
}
FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_HANDLER(22, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *value;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed refcounting for references
2014-09-11 15:12:12 +00:00
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
Improved ternary operator performance when returning arrays
2011-10-18 19:42:42 +00:00
Fixed refcounting for references
2014-09-11 15:12:12 +00:00
if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && Z_ISREF_P(value)) {
ZVAL_COPY(EX_VAR(opline->result.var), Z_REFVAL_P(value));
FREE_OP1();
} else {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
if (OP1_TYPE == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
zval_copy_ctor_func(EX_VAR(opline->result.var));
}
} else if (OP1_TYPE == IS_CV) {
if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
Improved ternary operator performance when returning arrays
2011-10-18 19:42:42 +00:00
}
}
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_HANDLER(101, ZEND_EXT_STMT, ANY, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (!EG(no_extensions)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, EX(func));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(102, ZEND_EXT_FCALL_BEGIN, ANY, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (!EG(no_extensions)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, EX(func));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(103, ZEND_EXT_FCALL_END, ANY, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (!EG(no_extensions)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, EX(func));
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(139, ZEND_DECLARE_CLASS, ANY, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
Z_CE_P(EX_VAR(opline->result.var)) = do_bind_class(&EX(func)->op_array, opline, EG(class_table), 0);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Implemented concept of "delayed early binding" that allows opcode caches to perform class declaration (early and/or run-time binding) in exactly the same order as vanila php. The following pseudo-code explains how it should be used in opcode cache. function cache_compile_file($filename) { if (!is_cached($filename)) { ... orig_compiler_options = CG(compiler_optins); CG(compiler_options) |= ZEND_COMPILE_IGNORE_INTERNAL_CLASSES | ZEND_COMPILE_DELAYED_BINDING; $op_array = orig_compile_file($filename); CG(compiler_options) = orig_copiler_options; ... } else { $op_array = restore_from_cache($filename); } zend_do_delayed_early_binding($op_array); }
2008-03-18 08:36:30 +00:00
ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, ANY, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *zce, *orig_zce;
Implemented concept of "delayed early binding" that allows opcode caches to perform class declaration (early and/or run-time binding) in exactly the same order as vanila php. The following pseudo-code explains how it should be used in opcode cache. function cache_compile_file($filename) { if (!is_cached($filename)) { ... orig_compiler_options = CG(compiler_optins); CG(compiler_options) |= ZEND_COMPILE_IGNORE_INTERNAL_CLASSES | ZEND_COMPILE_DELAYED_BINDING; $op_array = orig_compile_file($filename); CG(compiler_options) = orig_copiler_options; ... } else { $op_array = restore_from_cache($filename); } zend_do_delayed_early_binding($op_array); }
2008-03-18 08:36:30 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if ((zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)))) == NULL ||
((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)))) != NULL &&
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
Z_CE_P(zce) != Z_CE_P(orig_zce))) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0);
Implemented concept of "delayed early binding" that allows opcode caches to perform class declaration (early and/or run-time binding) in exactly the same order as vanila php. The following pseudo-code explains how it should be used in opcode cache. function cache_compile_file($filename) { if (!is_cached($filename)) { ... orig_compiler_options = CG(compiler_optins); CG(compiler_options) |= ZEND_COMPILE_IGNORE_INTERNAL_CLASSES | ZEND_COMPILE_DELAYED_BINDING; $op_array = orig_compile_file($filename); CG(compiler_options) = orig_copiler_options; ... } else { $op_array = restore_from_cache($filename); } zend_do_delayed_early_binding($op_array); }
2008-03-18 08:36:30 +00:00
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
Implemented concept of "delayed early binding" that allows opcode caches to perform class declaration (early and/or run-time binding) in exactly the same order as vanila php. The following pseudo-code explains how it should be used in opcode cache. function cache_compile_file($filename) { if (!is_cached($filename)) { ... orig_compiler_options = CG(compiler_optins); CG(compiler_options) |= ZEND_COMPILE_IGNORE_INTERNAL_CLASSES | ZEND_COMPILE_DELAYED_BINDING; $op_array = orig_compile_file($filename); CG(compiler_options) = orig_copiler_options; ... } else { $op_array = restore_from_cache($filename); } zend_do_delayed_early_binding($op_array); }
2008-03-18 08:36:30 +00:00
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_HANDLER(141, ZEND_DECLARE_FUNCTION, ANY, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
SAVE_OPLINE();
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
do_bind_function(&EX(func)->op_array, opline, EG(function_table), 0);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
ZEND_VM_HANDLER(105, ZEND_TICKS, ANY, ANY)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Fixed compilation warnings
2014-12-12 18:57:34 +00:00
if ((uint32_t)++EG(ticks_count) >= opline->extended_value) {
EG(ticks_count) = 0;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
if (zend_ticks_function) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_ticks_function(opline->extended_value);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
}
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
ZEND_VM_HANDLER(138, ZEND_INSTANCEOF, TMPVAR|CV, CONST|VAR)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_free_op free_op1;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *expr;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
zend_bool result;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
fix UMR when variable name is an object and __toString is used # zend_call_function checks IS_REF on This
2011-03-16 05:25:02 +00:00
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
ZEND_VM_C_LABEL(try_instanceof):
Remove support for classes without class entries get_class_entry must be non-NULL and return non-NULL.
2014-10-09 11:58:14 +00:00
if (Z_TYPE_P(expr) == IS_OBJECT) {
Embed FETCH_CLASS <string> into the following INSTANCEOF
2014-10-22 13:23:43 +00:00
zend_class_entry *ce;
if (OP2_TYPE == IS_CONST) {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) {
ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
Embed FETCH_CLASS <string> into the following INSTANCEOF
2014-10-22 13:23:43 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
Embed FETCH_CLASS <string> into the following INSTANCEOF
2014-10-22 13:23:43 +00:00
if (UNEXPECTED(ce == NULL)) {
ZVAL_FALSE(EX_VAR(opline->result.var));
FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
Embed FETCH_CLASS <string> into the following INSTANCEOF
2014-10-22 13:23:43 +00:00
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
Improve "instanceof". Interfaces of the left operand should be checked only if the right operand is interafce itself.
2015-01-14 12:06:26 +00:00
result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
} else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
expr = Z_REFVAL_P(expr);
ZEND_VM_C_GOTO(try_instanceof);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
} else {
result = 0;
}
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_BOOL(EX_VAR(opline->result.var), result);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
FREE_OP1();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(104, ZEND_EXT_NOP, ANY, ANY)
{
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(0, ZEND_NOP, ANY, ANY)
{
ZEND_VM_NEXT_OPCODE();
}
Optimized ZEND_FETCH_CLASS + ZEND_ADD_INTERFACE into single ZEND_ADD_INTERFACE opcode
2008-03-12 10:32:12 +00:00
ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST)
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zend_class_entry *iface;
SAVE_OPLINE();
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) {
iface = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
iface = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_INTERFACE);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
if (UNEXPECTED(iface == NULL)) {
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
- Fixed bug #49908 (throwing exception in __autoload crashes when interface is not defined)
2009-11-01 21:26:03 +00:00
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), iface);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
}
if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
Fixed error messages
2014-02-21 16:44:26 +00:00
zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name->val, iface->name->val);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_do_implement_interface(ce, iface);
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Implemented Traits for PHP as proposed in the RFC [TRAITS] # RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior # Ok, here we go, I guess that will result in more discussion, which is fine # by me. But now, the patch is here, and properly archived. # # See below a list of notes to the patch, it also includes a list of # points which should be fixed # # Internals of the Traits Patch # ----------------------------- # # Open TODOs # """""""""" # # - Reflection API # - support for traits for internal classes # - currently destroy_zend_class does not handle that case # # Introduced Structures # """"""""""""""""""""" # # Data structures to encode the composition information specified in the # source: # - zend_trait_method_reference # - zend_trait_precedence # - zend_trait_alias # # Changes # """"""" # # zend_class_entry # - uses NULL terminated lists of pointers for # - trait_aliases # - trait_precedences # - do you prefer an explicit counter? # - the information is only necessary during class composition # but might be interesting for reflection # - did not want to blow up class further with not really necessary length counters # # added keywords # - trait # - insteadof # # Added opcodes # ZEND_ADD_TRAIT # - similar to ZEND_ADD_INTERFACE # - adds the trait to the list of traits of a class, no actual composition done # ZEND_BIND_TRAITS # - emitted in zend_do_end_class_declaration # - concludes the class definition and will initiate the trait composition # when the class definition is encountered during runtime # # Added Flags # ZEND_ACC_TRAIT = 0x120 # ZEND_ACC_IMPLEMENT_TRAITS = 0x400000 # ZEND_FETCH_CLASS_TRAIT = 14 # # zend_vm_execute.h # - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER, # ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective # # zend_compile.c # - refactored do_inherit_method_check # split into do_inherit_method_check and do_inheritance_check_on_method # - added helper functions use a '_' as prefix and are not mentioned in the # headers # - _copy_functions # prepare hash-maps of functions which should be merged into a class # here the aliases are handled # - _merge_functions # builds a hash-table of the methods which need to be added to a class # does the conflict detection # - reused php_runkit_function_copy_ctor # - it is not identical with the original code anymore, needed to update it # think I fixed some bugs, not sure whether all have been reported back to runkit # - has to be renamed, left the name for the moment, to make its origin obvious # - here might be optimization potential # - not sure whether everything needs to be copied # - copying the literals might be broken # - added it since the literals array is freed by efree and gave problems # with doubled frees # - all immutable parts of the zend_op array should not be copied # - am not sure which parts are immutable # - and not sure how to avoid doubled frees on the same arrays on shutdown # - _merge_functions_to_class # does the final merging with the target class to handle inherited # and overridden methods # - small helper for NULL terminated lists # zend_init_list, zend_add_to_list # # zend_language_parser.y # - reused class definition for traits # - there should be something with regard to properties # - if they get explicitly defined, it might be worthwhile to # check that there are no collisions with other traits in a composition # (however, I would not introduce elaborate language features to control that # but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY)
{
Fixed direct threaded executor (php zend_vm_gen.php --with-vm-kind=GOTO)
2011-05-05 16:02:11 +00:00
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
zend_class_entry *trait;
Fixed direct threaded executor (php zend_vm_gen.php --with-vm-kind=GOTO)
2011-05-05 16:02:11 +00:00
SAVE_OPLINE();
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) {
trait = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
} else {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
trait = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)),
EX_CONSTANT(opline->op2) + 1,
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
ZEND_FETCH_CLASS_TRAIT);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
if (UNEXPECTED(trait == NULL)) {
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Made ZEND_ACC_TRAIT a saner value CC_TRAIT valued as 0x120 is too magical to be comprehensible by others.
2015-02-12 22:19:14 +00:00
if (!(trait->ce_flags & ZEND_ACC_TRAIT)) {
Fixed error messages
2014-02-21 16:44:26 +00:00
zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name->val, trait->name->val);
Implemented Traits for PHP as proposed in the RFC [TRAITS] # RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior # Ok, here we go, I guess that will result in more discussion, which is fine # by me. But now, the patch is here, and properly archived. # # See below a list of notes to the patch, it also includes a list of # points which should be fixed # # Internals of the Traits Patch # ----------------------------- # # Open TODOs # """""""""" # # - Reflection API # - support for traits for internal classes # - currently destroy_zend_class does not handle that case # # Introduced Structures # """"""""""""""""""""" # # Data structures to encode the composition information specified in the # source: # - zend_trait_method_reference # - zend_trait_precedence # - zend_trait_alias # # Changes # """"""" # # zend_class_entry # - uses NULL terminated lists of pointers for # - trait_aliases # - trait_precedences # - do you prefer an explicit counter? # - the information is only necessary during class composition # but might be interesting for reflection # - did not want to blow up class further with not really necessary length counters # # added keywords # - trait # - insteadof # # Added opcodes # ZEND_ADD_TRAIT # - similar to ZEND_ADD_INTERFACE # - adds the trait to the list of traits of a class, no actual composition done # ZEND_BIND_TRAITS # - emitted in zend_do_end_class_declaration # - concludes the class definition and will initiate the trait composition # when the class definition is encountered during runtime # # Added Flags # ZEND_ACC_TRAIT = 0x120 # ZEND_ACC_IMPLEMENT_TRAITS = 0x400000 # ZEND_FETCH_CLASS_TRAIT = 14 # # zend_vm_execute.h # - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER, # ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective # # zend_compile.c # - refactored do_inherit_method_check # split into do_inherit_method_check and do_inheritance_check_on_method # - added helper functions use a '_' as prefix and are not mentioned in the # headers # - _copy_functions # prepare hash-maps of functions which should be merged into a class # here the aliases are handled # - _merge_functions # builds a hash-table of the methods which need to be added to a class # does the conflict detection # - reused php_runkit_function_copy_ctor # - it is not identical with the original code anymore, needed to update it # think I fixed some bugs, not sure whether all have been reported back to runkit # - has to be renamed, left the name for the moment, to make its origin obvious # - here might be optimization potential # - not sure whether everything needs to be copied # - copying the literals might be broken # - added it since the literals array is freed by efree and gave problems # with doubled frees # - all immutable parts of the zend_op array should not be copied # - am not sure which parts are immutable # - and not sure how to avoid doubled frees on the same arrays on shutdown # - _merge_functions_to_class # does the final merging with the target class to handle inherited # and overridden methods # - small helper for NULL terminated lists # zend_init_list, zend_add_to_list # # zend_language_parser.y # - reused class definition for traits # - there should be something with regard to properties # - if they get explicitly defined, it might be worthwhile to # check that there are no collisions with other traits in a composition # (however, I would not introduce elaborate language features to control that # but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), trait);
Implemented Traits for PHP as proposed in the RFC [TRAITS] # RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior # Ok, here we go, I guess that will result in more discussion, which is fine # by me. But now, the patch is here, and properly archived. # # See below a list of notes to the patch, it also includes a list of # points which should be fixed # # Internals of the Traits Patch # ----------------------------- # # Open TODOs # """""""""" # # - Reflection API # - support for traits for internal classes # - currently destroy_zend_class does not handle that case # # Introduced Structures # """"""""""""""""""""" # # Data structures to encode the composition information specified in the # source: # - zend_trait_method_reference # - zend_trait_precedence # - zend_trait_alias # # Changes # """"""" # # zend_class_entry # - uses NULL terminated lists of pointers for # - trait_aliases # - trait_precedences # - do you prefer an explicit counter? # - the information is only necessary during class composition # but might be interesting for reflection # - did not want to blow up class further with not really necessary length counters # # added keywords # - trait # - insteadof # # Added opcodes # ZEND_ADD_TRAIT # - similar to ZEND_ADD_INTERFACE # - adds the trait to the list of traits of a class, no actual composition done # ZEND_BIND_TRAITS # - emitted in zend_do_end_class_declaration # - concludes the class definition and will initiate the trait composition # when the class definition is encountered during runtime # # Added Flags # ZEND_ACC_TRAIT = 0x120 # ZEND_ACC_IMPLEMENT_TRAITS = 0x400000 # ZEND_FETCH_CLASS_TRAIT = 14 # # zend_vm_execute.h # - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER, # ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective # # zend_compile.c # - refactored do_inherit_method_check # split into do_inherit_method_check and do_inheritance_check_on_method # - added helper functions use a '_' as prefix and are not mentioned in the # headers # - _copy_functions # prepare hash-maps of functions which should be merged into a class # here the aliases are handled # - _merge_functions # builds a hash-table of the methods which need to be added to a class # does the conflict detection # - reused php_runkit_function_copy_ctor # - it is not identical with the original code anymore, needed to update it # think I fixed some bugs, not sure whether all have been reported back to runkit # - has to be renamed, left the name for the moment, to make its origin obvious # - here might be optimization potential # - not sure whether everything needs to be copied # - copying the literals might be broken # - added it since the literals array is freed by efree and gave problems # with doubled frees # - all immutable parts of the zend_op array should not be copied # - am not sure which parts are immutable # - and not sure how to avoid doubled frees on the same arrays on shutdown # - _merge_functions_to_class # does the final merging with the target class to handle inherited # and overridden methods # - small helper for NULL terminated lists # zend_init_list, zend_add_to_list # # zend_language_parser.y # - reused class definition for traits # - there should be something with regard to properties # - if they get explicitly defined, it might be worthwhile to # check that there are no collisions with other traits in a composition # (however, I would not introduce elaborate language features to control that # but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_do_implement_trait(ce, trait);
Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties
2010-05-24 14:11:39 +00:00
Added compiler hints
2010-05-06 12:52:27 +00:00
CHECK_EXCEPTION();
Implemented Traits for PHP as proposed in the RFC [TRAITS] # RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior # Ok, here we go, I guess that will result in more discussion, which is fine # by me. But now, the patch is here, and properly archived. # # See below a list of notes to the patch, it also includes a list of # points which should be fixed # # Internals of the Traits Patch # ----------------------------- # # Open TODOs # """""""""" # # - Reflection API # - support for traits for internal classes # - currently destroy_zend_class does not handle that case # # Introduced Structures # """"""""""""""""""""" # # Data structures to encode the composition information specified in the # source: # - zend_trait_method_reference # - zend_trait_precedence # - zend_trait_alias # # Changes # """"""" # # zend_class_entry # - uses NULL terminated lists of pointers for # - trait_aliases # - trait_precedences # - do you prefer an explicit counter? # - the information is only necessary during class composition # but might be interesting for reflection # - did not want to blow up class further with not really necessary length counters # # added keywords # - trait # - insteadof # # Added opcodes # ZEND_ADD_TRAIT # - similar to ZEND_ADD_INTERFACE # - adds the trait to the list of traits of a class, no actual composition done # ZEND_BIND_TRAITS # - emitted in zend_do_end_class_declaration # - concludes the class definition and will initiate the trait composition # when the class definition is encountered during runtime # # Added Flags # ZEND_ACC_TRAIT = 0x120 # ZEND_ACC_IMPLEMENT_TRAITS = 0x400000 # ZEND_FETCH_CLASS_TRAIT = 14 # # zend_vm_execute.h # - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER, # ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective # # zend_compile.c # - refactored do_inherit_method_check # split into do_inherit_method_check and do_inheritance_check_on_method # - added helper functions use a '_' as prefix and are not mentioned in the # headers # - _copy_functions # prepare hash-maps of functions which should be merged into a class # here the aliases are handled # - _merge_functions # builds a hash-table of the methods which need to be added to a class # does the conflict detection # - reused php_runkit_function_copy_ctor # - it is not identical with the original code anymore, needed to update it # think I fixed some bugs, not sure whether all have been reported back to runkit # - has to be renamed, left the name for the moment, to make its origin obvious # - here might be optimization potential # - not sure whether everything needs to be copied # - copying the literals might be broken # - added it since the literals array is freed by efree and gave problems # with doubled frees # - all immutable parts of the zend_op array should not be copied # - am not sure which parts are immutable # - and not sure how to avoid doubled frees on the same arrays on shutdown # - _merge_functions_to_class # does the final merging with the target class to handle inherited # and overridden methods # - small helper for NULL terminated lists # zend_init_list, zend_add_to_list # # zend_language_parser.y # - reused class definition for traits # - there should be something with regard to properties # - if they get explicitly defined, it might be worthwhile to # check that there are no collisions with other traits in a composition # (however, I would not introduce elaborate language features to control that # but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(155, ZEND_BIND_TRAITS, ANY, ANY)
{
Fixed direct threaded executor (php zend_vm_gen.php --with-vm-kind=GOTO)
2011-05-05 16:02:11 +00:00
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
fix UMR when variable name is an object and __toString is used # zend_call_function checks IS_REF on This
2011-03-16 05:25:02 +00:00
Fixed direct threaded executor (php zend_vm_gen.php --with-vm-kind=GOTO)
2011-05-05 16:02:11 +00:00
SAVE_OPLINE();
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_do_bind_traits(ce);
Fixed direct threaded executor (php zend_vm_gen.php --with-vm-kind=GOTO)
2011-05-05 16:02:11 +00:00
CHECK_EXCEPTION();
Implemented Traits for PHP as proposed in the RFC [TRAITS] # RFC http://wiki.php.net/rfc/horizontalreuse#traits_-_reuse_of_behavior # Ok, here we go, I guess that will result in more discussion, which is fine # by me. But now, the patch is here, and properly archived. # # See below a list of notes to the patch, it also includes a list of # points which should be fixed # # Internals of the Traits Patch # ----------------------------- # # Open TODOs # """""""""" # # - Reflection API # - support for traits for internal classes # - currently destroy_zend_class does not handle that case # # Introduced Structures # """"""""""""""""""""" # # Data structures to encode the composition information specified in the # source: # - zend_trait_method_reference # - zend_trait_precedence # - zend_trait_alias # # Changes # """"""" # # zend_class_entry # - uses NULL terminated lists of pointers for # - trait_aliases # - trait_precedences # - do you prefer an explicit counter? # - the information is only necessary during class composition # but might be interesting for reflection # - did not want to blow up class further with not really necessary length counters # # added keywords # - trait # - insteadof # # Added opcodes # ZEND_ADD_TRAIT # - similar to ZEND_ADD_INTERFACE # - adds the trait to the list of traits of a class, no actual composition done # ZEND_BIND_TRAITS # - emitted in zend_do_end_class_declaration # - concludes the class definition and will initiate the trait composition # when the class definition is encountered during runtime # # Added Flags # ZEND_ACC_TRAIT = 0x120 # ZEND_ACC_IMPLEMENT_TRAITS = 0x400000 # ZEND_FETCH_CLASS_TRAIT = 14 # # zend_vm_execute.h # - not sure whether the handler initialization (ZEND_ADD_TRAIT_SPEC_HANDLER, # ZEND_BIND_TRAITS_SPEC_HANDLER) is correct, maybe it should be more selective # # zend_compile.c # - refactored do_inherit_method_check # split into do_inherit_method_check and do_inheritance_check_on_method # - added helper functions use a '_' as prefix and are not mentioned in the # headers # - _copy_functions # prepare hash-maps of functions which should be merged into a class # here the aliases are handled # - _merge_functions # builds a hash-table of the methods which need to be added to a class # does the conflict detection # - reused php_runkit_function_copy_ctor # - it is not identical with the original code anymore, needed to update it # think I fixed some bugs, not sure whether all have been reported back to runkit # - has to be renamed, left the name for the moment, to make its origin obvious # - here might be optimization potential # - not sure whether everything needs to be copied # - copying the literals might be broken # - added it since the literals array is freed by efree and gave problems # with doubled frees # - all immutable parts of the zend_op array should not be copied # - am not sure which parts are immutable # - and not sure how to avoid doubled frees on the same arrays on shutdown # - _merge_functions_to_class # does the final merging with the target class to handle inherited # and overridden methods # - small helper for NULL terminated lists # zend_init_list, zend_add_to_list # # zend_language_parser.y # - reused class definition for traits # - there should be something with regard to properties # - if they get explicitly defined, it might be worthwhile to # check that there are no collisions with other traits in a composition # (however, I would not introduce elaborate language features to control that # but a notice for such conflicts might be nice to the developers)
2010-04-22 22:05:56 +00:00
ZEND_VM_NEXT_OPCODE();
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
{
master renames phase 2
2014-08-25 17:28:33 +00:00
uint32_t op_num = EG(opline_before_exception) - EX(func)->op_array.opcodes;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
int i;
master renames phase 2
2014-08-25 17:28:33 +00:00
uint32_t catch_op_num = 0, finally_op_num = 0, finally_op_end = 0;
Fixed "finally" handling (the bug was introduced by recent removing of EX(delayed_exception))
2014-12-02 13:05:30 +00:00
int in_finally = 0;
Changed EG(argument_stack) implementation.
2008-01-24 09:41:39 +00:00
improved timeout handling on windows
2015-03-16 16:48:29 +00:00
ZEND_VM_INTERRUPT_CHECK();
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
for (i = 0; i < EX(func)->op_array.last_try_catch; i++) {
if (EX(func)->op_array.try_catch_array[i].try_op > op_num) {
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
/* further blocks will not be relevant... */
break;
Use zend_execute_internal always to call internal functions
2012-10-05 06:14:20 +00:00
}
Fixed "finally" handling (the bug was introduced by recent removing of EX(delayed_exception))
2014-12-02 13:05:30 +00:00
in_finally = 0;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (op_num < EX(func)->op_array.try_catch_array[i].catch_op) {
catch_op_num = EX(func)->op_array.try_catch_array[i].catch_op;
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (op_num < EX(func)->op_array.try_catch_array[i].finally_op) {
finally_op_num = EX(func)->op_array.try_catch_array[i].finally_op;
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
finally_op_end = EX(func)->op_array.try_catch_array[i].finally_end;
Add functions declarations, use tabs
2012-08-14 00:59:40 +00:00
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (op_num >= EX(func)->op_array.try_catch_array[i].finally_op &&
op_num < EX(func)->op_array.try_catch_array[i].finally_end) {
finally_op_end = EX(func)->op_array.try_catch_array[i].finally_end;
Fixed "finally" handling (the bug was introduced by recent removing of EX(delayed_exception))
2014-12-02 13:05:30 +00:00
in_finally = 1;
Fixed bug #65784 (Segfault with finally).
2013-12-12 16:15:50 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
if (UNEXPECTED(EX(call))) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
zend_execute_data *call = EX(call);
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
zend_op *opline = EX(func)->op_array.opcodes + op_num;
int level;
int do_exit;
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
do {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
/* If the exception was thrown during a function call there might be
* arguments pushed to the stack that have to be dtor'ed. */
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
/* find the number of actually passed arguments */
level = 0;
do_exit = 0;
do {
switch (opline->opcode) {
case ZEND_DO_FCALL:
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
case ZEND_DO_ICALL:
case ZEND_DO_UCALL:
case ZEND_DO_FCALL_BY_NAME:
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
level++;
trailing whitespace removal
2015-01-03 09:22:58 +00:00
break;
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
case ZEND_INIT_FCALL:
case ZEND_INIT_FCALL_BY_NAME:
case ZEND_INIT_NS_FCALL_BY_NAME:
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
case ZEND_INIT_DYNAMIC_CALL:
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
case ZEND_INIT_USER_CALL:
case ZEND_INIT_METHOD_CALL:
case ZEND_INIT_STATIC_METHOD_CALL:
case ZEND_NEW:
if (level == 0) {
ZEND_CALL_NUM_ARGS(call) = 0;
trailing whitespace removal
2015-01-03 09:22:58 +00:00
do_exit = 1;
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
}
level--;
break;
case ZEND_SEND_VAL:
case ZEND_SEND_VAL_EX:
case ZEND_SEND_VAR:
case ZEND_SEND_VAR_EX:
case ZEND_SEND_REF:
case ZEND_SEND_VAR_NO_REF:
case ZEND_SEND_USER:
if (level == 0) {
ZEND_CALL_NUM_ARGS(call) = opline->op2.num;
trailing whitespace removal
2015-01-03 09:22:58 +00:00
do_exit = 1;
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
}
break;
case ZEND_SEND_ARRAY:
case ZEND_SEND_UNPACK:
if (level == 0) {
do_exit = 1;
}
break;
}
if (!do_exit) {
opline--;
}
} while (!do_exit);
if (call->prev_execute_data) {
/* skip current call region */
level = 0;
do_exit = 0;
do {
switch (opline->opcode) {
case ZEND_DO_FCALL:
Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods)
2015-02-25 07:37:21 +00:00
case ZEND_DO_ICALL:
case ZEND_DO_UCALL:
case ZEND_DO_FCALL_BY_NAME:
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
level++;
trailing whitespace removal
2015-01-03 09:22:58 +00:00
break;
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
case ZEND_INIT_FCALL:
case ZEND_INIT_FCALL_BY_NAME:
case ZEND_INIT_NS_FCALL_BY_NAME:
Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV)
2015-02-24 19:29:47 +00:00
case ZEND_INIT_DYNAMIC_CALL:
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
case ZEND_INIT_USER_CALL:
case ZEND_INIT_METHOD_CALL:
case ZEND_INIT_STATIC_METHOD_CALL:
case ZEND_NEW:
if (level == 0) {
trailing whitespace removal
2015-01-03 09:22:58 +00:00
do_exit = 1;
Optimize argument passing handlers: - predcalculate offsets of passed argument and store it in opline->result.var for ZEND_SEND_*; - don't update "number of passed arguments" op each ZEND_SEND_* opcode, store it on call frame creation - Change ZEND_HANDLE_EXCEPTION to determine "number of passed arguments" in incomplete calls fefore freeing
2014-12-16 15:40:52 +00:00
}
level--;
break;
}
opline--;
} while (!do_exit);
}
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_free_args(EX(call));
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (Z_OBJ(call->This)) {
Pack EX(frame_info) into EX(This).u1.v.reserved. Rename "frame"kind" into "call_kind" and VM_FRAME_... into ZEND_CALL_...
2014-11-28 07:33:03 +00:00
if (ZEND_CALL_INFO(call) & ZEND_CALL_CTOR) {
if (!(ZEND_CALL_INFO(call) & ZEND_CALL_CTOR_RESULT_UNUSED)) {
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
GC_REFCOUNT(Z_OBJ(call->This))--;
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
}
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
if (GC_REFCOUNT(Z_OBJ(call->This)) == 1) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_object_store_ctor_failed(Z_OBJ(call->This));
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
}
Fixed bug #47771 (Exception during object construction from arg call calls object's destructor)
2009-03-26 10:17:30 +00:00
}
Replaced EG(This) and EX(object) with EX(This). Internal functions now recieves zend_execute_data as the first argument.
2014-10-03 15:32:46 +00:00
OBJ_RELEASE(Z_OBJ(call->This));
Fixed bug #31177 (menory leaks and corruption because of incorrect refcounting)
2005-10-20 07:23:26 +00:00
}
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 17:26:09 +00:00
if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) {
zend_string_release(call->func->common.function_name);
efree(call->func);
Fixed bug #69212
2015-03-10 17:17:56 +00:00
}
Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h
2015-03-10 17:26:09 +00:00
Removed zend_execute_data->prev_nested_call. Reuse prev_execute_data instead.
2014-10-01 06:46:13 +00:00
EX(call) = call->prev_execute_data;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_vm_stack_free_call_frame(call);
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
call = EX(call);
} while (call);
Fixed bug #30707 (Segmentation fault on exception in method)
2005-05-04 11:17:30 +00:00
}
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
for (i = 0; i < EX(func)->op_array.last_brk_cont; i++) {
if (EX(func)->op_array.brk_cont_array[i].start < 0) {
Fixed bug #44184 (Double free of loop-variable on exception)
2008-02-20 12:05:57 +00:00
continue;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
} else if (EX(func)->op_array.brk_cont_array[i].start > op_num) {
Fixed bugs #34065 and #38623 (throw in foreach/switch causes memory leaks)
2006-09-19 21:36:54 +00:00
/* further blocks will not be relevant... */
break;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
} else if (op_num < EX(func)->op_array.brk_cont_array[i].brk) {
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
if (!catch_op_num ||
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
catch_op_num >= EX(func)->op_array.brk_cont_array[i].brk) {
zend_op *brk_opline = &EX(func)->op_array.opcodes[EX(func)->op_array.brk_cont_array[i].brk];
Fixed bugs #34065 and #38623 (throw in foreach/switch causes memory leaks)
2006-09-19 21:36:54 +00:00
Use zval_ptr_dtor_nogc() to free IS_TMP_VAR operands. Removed ZEND_SWITCH_FREE opcode (ZEND_FREE used instead).
2014-09-23 13:21:29 +00:00
if (brk_opline->opcode == ZEND_FREE) {
Simplify code
2014-06-05 14:42:17 +00:00
if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
Use zval_ptr_dtor_nogc() to free IS_TMP_VAR operands. Removed ZEND_SWITCH_FREE opcode (ZEND_FREE used instead).
2014-09-23 13:21:29 +00:00
zval_ptr_dtor_nogc(EX_VAR(brk_opline->op1.var));
Simplify code
2014-06-05 14:42:17 +00:00
}
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 10:57:12 +00:00
} else if (brk_opline->opcode == ZEND_FE_FREE) {
if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
zval *var = EX_VAR(brk_opline->op1.var);
if (Z_TYPE_P(var) != IS_ARRAY && Z_FE_ITER_P(var) != (uint32_t)-1) {
zend_hash_iterator_del(Z_FE_ITER_P(var));
}
zval_ptr_dtor_nogc(var);
}
Reimplemented silence operator (@) handling on exceptions. Now each silence region is stored in op_array->brk_cont_array. On exception ZEND_HANDLE_EXCEPTION handler traverse this array and restore original EG(error_reporting) if exception occured inside a "silence" region.
2014-11-26 19:44:58 +00:00
} else if (brk_opline->opcode == ZEND_END_SILENCE) {
/* restore previous error_reporting value */
if (!EG(error_reporting) && Z_LVAL_P(EX_VAR(brk_opline->op1.var)) != 0) {
EG(error_reporting) = Z_LVAL_P(EX_VAR(brk_opline->op1.var));
}
Fixed bugs #34065 and #38623 (throw in foreach/switch causes memory leaks)
2006-09-19 21:36:54 +00:00
}
}
}
}
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
if (finally_op_num && (!catch_op_num || catch_op_num >= finally_op_num)) {
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[finally_op_end].op1.var);
Fixed "finally" handling (the bug was introduced by recent removing of EX(delayed_exception))
2014-12-02 13:05:30 +00:00
if (in_finally && Z_OBJ_P(fast_call)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_exception_set_previous(EG(exception), Z_OBJ_P(fast_call));
trailing whitespace removal
2015-01-03 09:22:58 +00:00
}
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
Z_OBJ_P(fast_call) = EG(exception);
Fixed bug #65784 (Segfault with finally).
2013-12-12 16:15:50 +00:00
EG(exception) = NULL;
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
fast_call->u2.lineno = (uint32_t)-1;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[finally_op_num]);
Add functions declarations, use tabs
2012-08-14 00:59:40 +00:00
ZEND_VM_CONTINUE();
} else {
Fixed "finally" handling (the bug was introduced by recent removing of EX(delayed_exception))
2014-12-02 13:05:30 +00:00
if (in_finally) {
/* we are going out of current finally scope */
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[finally_op_end].op1.var);
if (Z_OBJ_P(fast_call)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_exception_set_previous(EG(exception), Z_OBJ_P(fast_call));
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
Z_OBJ_P(fast_call) = NULL;
}
Fixed bug #65784 (Segfault with finally).
2013-12-12 16:15:50 +00:00
}
Fixed "finally" handling (the bug was introduced by recent removing of EX(delayed_exception))
2014-12-02 13:05:30 +00:00
if (catch_op_num) {
ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[catch_op_num]);
ZEND_VM_CONTINUE();
} else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_GENERATOR) != 0)) {
Implement Generator::getReturn() Conflicts: Zend/zend_vm_execute.h
2015-02-19 19:17:37 +00:00
/* The generator object is stored in EX(return_value) */
zend_generator *generator = (zend_generator *) EX(return_value);
zend_generator_close(generator, 1);
ZEND_VM_RETURN();
- generators API exported for extensions - improved RETURN sequence to avoid redundant check if op_array is a generator
2012-12-11 13:25:32 +00:00
} else {
ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
}
Add functions declarations, use tabs
2012-08-14 00:59:40 +00:00
}
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
}
ZEND_VM_HANDLER(146, ZEND_VERIFY_ABSTRACT_CLASS, ANY, ANY)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
SAVE_OPLINE();
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_verify_abstract_class(Z_CE_P(EX_VAR(opline->op1.var)));
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
- Commit new VM - Old one is tagged as PRE_NEW_VM_GEN_PATCH - Still doing work so more commits to come. Don't complain (yet) :)
2004-10-22 21:42:14 +00:00
ZEND_VM_NEXT_OPCODE();
}
Fix so that extensions like xdebug, can overload opcodes in all execution modes including goto/switch
2005-06-10 09:54:38 +00:00
ZEND_VM_HANDLER(150, ZEND_USER_OPCODE, ANY, ANY)
- MFH missing bits and pieces of the partial sync with head # This time i added: # ZEND_FE_RESET_VARIABLE # ZEND_FE_RESET_REFERENCE # and dapted parser,compiler,executor,interfaces to handle these flags # their purpose is to be able to pass whetehr foreach is done by ref to # the current() handler so that it can error out in case it is not capable # to comply to the requested return signature/protocol/semantics (weyp).
2006-05-11 21:07:39 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
int ret;
fix UMR when variable name is an object and __toString is used # zend_call_function checks IS_REF on This
2011-03-16 05:25:02 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
ret = zend_user_opcode_handlers[opline->opcode](execute_data);
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
LOAD_OPLINE();
USER_OPCODE API is improvet. Implemented ability to dispatch from user handler to internal handler of another opcode.
2005-06-16 06:00:48 +00:00
switch (ret) {
Fix so that extensions like xdebug, can overload opcodes in all execution modes including goto/switch
2005-06-10 09:54:38 +00:00
case ZEND_USER_OPCODE_CONTINUE:
ZEND_VM_CONTINUE();
case ZEND_USER_OPCODE_RETURN:
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_GENERATOR) != 0)) {
Implement Generator::getReturn() Conflicts: Zend/zend_vm_execute.h
2015-02-19 19:17:37 +00:00
/* The generator object is stored in EX(return_value) */
zend_generator *generator = (zend_generator *) EX(return_value);
zend_generator_close(generator, 1);
ZEND_VM_RETURN();
- generators API exported for extensions - improved RETURN sequence to avoid redundant check if op_array is a generator
2012-12-11 13:25:32 +00:00
} else {
ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
}
Fixed ability to call user functions from user opcodes without recursion
2009-08-18 10:12:32 +00:00
case ZEND_USER_OPCODE_ENTER:
ZEND_VM_ENTER();
case ZEND_USER_OPCODE_LEAVE:
ZEND_VM_LEAVE();
Fix so that extensions like xdebug, can overload opcodes in all execution modes including goto/switch
2005-06-10 09:54:38 +00:00
case ZEND_USER_OPCODE_DISPATCH:
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
ZEND_VM_DISPATCH(opline->opcode, opline);
Fix so that extensions like xdebug, can overload opcodes in all execution modes including goto/switch
2005-06-10 09:54:38 +00:00
default:
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
ZEND_VM_DISPATCH((zend_uchar)(ret & 0xff), opline);
Fix so that extensions like xdebug, can overload opcodes in all execution modes including goto/switch
2005-06-10 09:54:38 +00:00
}
}
Namespaces
2007-09-28 19:52:53 +00:00
ZEND_VM_HANDLER(143, ZEND_DECLARE_CONST, CONST, CONST)
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Namespaces
2007-09-28 19:52:53 +00:00
zend_free_op free_op1, free_op2;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
zval *name;
zval *val;
Namespaces
2007-09-28 19:52:53 +00:00
zend_constant c;
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
name = GET_OP1_ZVAL_PTR(BP_VAR_R);
val = GET_OP2_ZVAL_PTR(BP_VAR_R);
Constant duplication optimization Argument receiving optimization
2014-04-03 23:55:27 +00:00
ZVAL_COPY_VALUE(&c.value, val);
if (Z_OPT_CONSTANT(c.value)) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zval_update_constant(&c.value, 0);
Namespaces
2007-09-28 19:52:53 +00:00
} else {
Constant duplication optimization Argument receiving optimization
2014-04-03 23:55:27 +00:00
/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
if (UNEXPECTED(Z_OPT_COPYABLE(c.value))) {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
zval_copy_ctor_func(&c.value);
Constant duplication optimization Argument receiving optimization
2014-04-03 23:55:27 +00:00
}
Namespaces
2007-09-28 19:52:53 +00:00
}
c.flags = CONST_CS; /* non persistent, case sensetive */
master renames phase 1
2014-08-25 17:24:55 +00:00
c.name = zend_string_dup(Z_STR_P(name), 0);
Namespaces
2007-09-28 19:52:53 +00:00
c.module_number = PHP_USER_CONSTANT;
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
if (zend_register_constant(&c) == FAILURE) {
Namespaces
2007-09-28 19:52:53 +00:00
}
FREE_OP1();
FREE_OP2();
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
Namespaces
2007-09-28 19:52:53 +00:00
ZEND_VM_NEXT_OPCODE();
}
Changed the structure of op_array.opcodes. The constant values are moved from opcode operands into a separate literal table
2010-04-20 10:57:45 +00:00
ZEND_VM_HANDLER(153, ZEND_DECLARE_LAMBDA_FUNCTION, CONST, UNUSED)
Added support for lambda functions and closures
2008-07-14 09:49:03 +00:00
{
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *zfunc;
Fix bug 666222 This also adds some smaller, isolated tests related to bug 66622.
2014-05-13 03:53:08 +00:00
int closure_is_static, closure_is_being_defined_inside_static_context;
Added support for lambda functions and closures
2008-07-14 09:49:03 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
SAVE_OPLINE();
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zfunc = zend_hash_find(EG(function_table), Z_STR_P(EX_CONSTANT(opline->op1)));
ZEND_ASSERT(zfunc != NULL && Z_FUNC_P(zfunc)->type == ZEND_USER_FUNCTION);
Added support for lambda functions and closures
2008-07-14 09:49:03 +00:00
Merge branch 'master' into phpng * master: (77 commits) NEWS entry for Fix potential segfault in dns_get_record() NEWS entry for "Fix potential segfault in dns_get_record()" NEWS entry for Fix potential segfault in dns_get_record( Fix potential segfault in dns_get_record() Revert "Add optional second arg to unserialize()" 5.5.15 now update NEWS Fix bug #66127 (Segmentation fault with ArrayObject unset) 5.4.31 next Add NEWS. This doesn't need UPGRADING (or an RFC), IMO. Fix broken test. Add a mime type map generation script and update the header. Move the mime type map out of php_cli_server.c for easier generation. Replace the CLI server's linear search for extensions with a hash table. fix test Remove unused included file NEWS NEWS NEWS Fixed Bug #67413 fileinfo: cdf_read_property_info insufficient boundary chec ... Conflicts: Zend/zend_closures.c Zend/zend_execute.c Zend/zend_vm_def.h Zend/zend_vm_execute.h ext/spl/spl_array.c ext/standard/basic_functions.c ext/standard/dns.c ext/standard/var.c
2014-06-12 01:07:33 +00:00
closure_is_static = Z_FUNC_P(zfunc)->common.fn_flags & ZEND_ACC_STATIC;
Simplify call-frame handling
2014-07-07 11:50:44 +00:00
closure_is_being_defined_inside_static_context = EX(func)->common.fn_flags & ZEND_ACC_STATIC;
Fix bug 666222 This also adds some smaller, isolated tests related to bug 66622.
2014-05-13 03:53:08 +00:00
if (closure_is_static || closure_is_being_defined_inside_static_context) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), EX(called_scope), NULL);
Fix bug 666222 This also adds some smaller, isolated tests related to bug 66622.
2014-05-13 03:53:08 +00:00
} else {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), EG(scope), Z_OBJ(EX(This)) ? &EX(This) : NULL);
Fix bug 666222 This also adds some smaller, isolated tests related to bug 66622.
2014-05-13 03:53:08 +00:00
}
Added support for lambda functions and closures
2008-07-14 09:49:03 +00:00
Added a number of small performance tweaks and optimizations . ZEND_RECV now always has IS_CV as its result . ZEND_CATCH now has to be used only with constant class names . ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order
2010-04-20 11:16:39 +00:00
CHECK_EXCEPTION();
Added support for lambda functions and closures
2008-07-14 09:49:03 +00:00
ZEND_VM_NEXT_OPCODE();
}
Fixed bug #52614 (Memory leak when writing on uninitialized variable returned from method call)
2010-08-25 09:14:36 +00:00
ZEND_VM_HANDLER(156, ZEND_SEPARATE, VAR, UNUSED)
{
USE_OPLINE
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
zval *var_ptr;
Fixed bug #52614 (Memory leak when writing on uninitialized variable returned from method call)
2010-08-25 09:14:36 +00:00
SAVE_OPLINE();
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
var_ptr = EX_VAR(opline->op1.var);
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
if (Z_TYPE_P(var_ptr) != IS_OBJECT &&
!Z_ISREF_P(var_ptr) &&
Z_REFCOUNTED_P(var_ptr) &&
Z_REFCOUNT_P(var_ptr) > 1) {
Z_DELREF_P(var_ptr);
Use better data structures (incomplete)
2014-02-10 06:04:30 +00:00
ZVAL_DUP(EX_VAR(opline->op1.var), var_ptr);
Fixed bug #52614 (Memory leak when writing on uninitialized variable returned from method call)
2010-08-25 09:14:36 +00:00
}
ZEND_VM_NEXT_OPCODE();
}
Merge remote-tracking branch 'php-src/master' into addGeneratorsSupport This is just an intial merge. It does not yet make generators and finally work together. Conflicts: Zend/zend_language_scanner.c Zend/zend_language_scanner_defs.h Zend/zend_vm_def.h Zend/zend_vm_execute.h Zend/zend_vm_execute.skl Zend/zend_vm_opcodes.h
2012-08-13 14:51:41 +00:00
ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSED)
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
{
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
USE_OPLINE
Generator related fixes
2014-02-26 09:58:59 +00:00
/* The generator object is stored in EX(return_value) */
zend_generator *generator = (zend_generator *) EX(return_value);
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
SAVE_OPLINE();
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot yield from finally in a force-closed generator");
FREE_UNFETCHED_OP2();
FREE_UNFETCHED_OP1();
HANDLE_EXCEPTION();
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
}
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
/* Destroy the previously yielded value */
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
zval_ptr_dtor(&generator->value);
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
Add support for yielding keys Keys are yielded using the yield $key => $value syntax. Currently this is implemented as a statement only and not as an expression, because conflicts arise considering nesting and use in arrays: yield yield $a => $b; // could be either yield (yield $a) => $b; // or yield (yield $a => $b); Once I find some way to resolve these conflicts this should be available as an expression too. Also the key yielding code is rather copy-and-past-y for the value yielding code, so that should be factored out.
2012-05-30 00:44:06 +00:00
/* Destroy the previously yielded key */
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
zval_ptr_dtor(&generator->key);
Add support for yielding keys Keys are yielded using the yield $key => $value syntax. Currently this is implemented as a statement only and not as an expression, because conflicts arise considering nesting and use in arrays: yield yield $a => $b; // could be either yield (yield $a) => $b; // or yield (yield $a => $b); Once I find some way to resolve these conflicts this should be available as an expression too. Also the key yielding code is rather copy-and-past-y for the value yielding code, so that should be factored out.
2012-05-30 00:44:06 +00:00
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
/* Set the new yielded value */
Allow to use yield without value If the generator is used as a coroutine it often doesn't make sense to yield anything. In this case one can simply receive values using $value = yield; The yield here will simply yield NULL.
2012-05-29 15:53:11 +00:00
if (OP1_TYPE != IS_UNUSED) {
Move a variable
2012-07-20 15:38:39 +00:00
zend_free_op free_op1;
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
if (EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
/* Constants and temporary variables aren't yieldable by reference,
* but we still allow them with a notice. */
if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
zval *value;
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
ZVAL_COPY_VALUE(&generator->value, value);
Various VM optimizations
2014-04-03 22:52:53 +00:00
if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
/* Temporary variables don't need ctor copying */
Replace IS_OP?_TMP_FREE() with more clear (OP?_TYPE == IS_TMP_VAR)
2014-09-22 08:47:10 +00:00
if (OP1_TYPE != IS_TMP_VAR) {
Avoid double checks
2014-09-24 08:20:46 +00:00
zval_opt_copy_ctor(&generator->value);
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
}
} else {
Fixed destruction of VM handler operands (FREE_OP1 and family)
2014-03-04 08:27:50 +00:00
zval *value_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
Removed IS_STR_OFFSET type and corresponding macros. Optimized string offset handling in ASSIGN_DIM opcode.
2014-09-08 11:46:45 +00:00
if (OP1_TYPE == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
Implement engine exceptions RFC: https://wiki.php.net/rfc/engine_exceptions_for_php7 Pending changes regarding naming of BaseException and whether it should be an interface.
2015-03-09 12:57:15 +00:00
zend_error(E_EXCEPTION | E_ERROR, "Cannot yield string offsets by reference");
FREE_UNFETCHED_OP2();
FREE_OP1();
HANDLE_EXCEPTION();
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
}
/* If a function call result is yielded and the function did
* not return by reference we throw a notice. */
Get rid of ZEND_FETCH_MAKE_REF
2014-10-22 17:45:02 +00:00
if (OP1_TYPE == IS_VAR &&
(value_ptr == &EG(uninitialized_zval) ||
(opline->extended_value == ZEND_RETURNS_FUNCTION &&
!(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) {
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
Use reference counting instead of zval duplication
2014-06-05 12:04:11 +00:00
ZVAL_MAKE_REF(value_ptr);
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
}
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
ZVAL_COPY(&generator->value, value_ptr);
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP1_VAR_PTR();
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
}
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
} else {
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
zval *value = GET_OP1_ZVAL_PTR(BP_VAR_R);
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
/* Consts, temporary variables and references need copying */
Cleanup
2014-04-15 21:45:40 +00:00
if (OP1_TYPE == IS_CONST) {
ZVAL_DUP(&generator->value, value);
} else if (OP1_TYPE == IS_TMP_VAR) {
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
ZVAL_COPY_VALUE(&generator->value, value);
Specialization (only IS_VAR ad IS_CV operands may be references)
2014-09-22 12:17:35 +00:00
} else if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) && Z_ISREF_P(value)) {
Cleanup
2014-04-15 21:45:40 +00:00
ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
FREE_OP1_IF_VAR();
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
} else {
Specialization (only IS_VAR ad IS_CV operands may be references)
2014-09-22 12:17:35 +00:00
ZVAL_COPY_VALUE(&generator->value, value);
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
if (OP1_TYPE == IS_CV) {
Specialization (only IS_VAR ad IS_CV operands may be references)
2014-09-22 12:17:35 +00:00
if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
Improved IS_VAR operands fetching
2013-05-17 09:15:09 +00:00
}
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
}
}
Allow to use yield without value If the generator is used as a coroutine it often doesn't make sense to yield anything. In this case one can simply receive values using $value = yield; The yield here will simply yield NULL.
2012-05-29 15:53:11 +00:00
} else {
Add support for yielding keys Keys are yielded using the yield $key => $value syntax. Currently this is implemented as a statement only and not as an expression, because conflicts arise considering nesting and use in arrays: yield yield $a => $b; // could be either yield (yield $a) => $b; // or yield (yield $a => $b); Once I find some way to resolve these conflicts this should be available as an expression too. Also the key yielding code is rather copy-and-past-y for the value yielding code, so that should be factored out.
2012-05-30 00:44:06 +00:00
/* If no value was specified yield null */
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
ZVAL_NULL(&generator->value);
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
}
Add support for yielding keys Keys are yielded using the yield $key => $value syntax. Currently this is implemented as a statement only and not as an expression, because conflicts arise considering nesting and use in arrays: yield yield $a => $b; // could be either yield (yield $a) => $b; // or yield (yield $a => $b); Once I find some way to resolve these conflicts this should be available as an expression too. Also the key yielding code is rather copy-and-past-y for the value yielding code, so that should be factored out.
2012-05-30 00:44:06 +00:00
/* Set the new yielded key */
if (OP2_TYPE != IS_UNUSED) {
zend_free_op free_op2;
zval *key = GET_OP2_ZVAL_PTR(BP_VAR_R);
/* Consts, temporary variables and references need copying */
Cleanup
2014-04-15 21:45:40 +00:00
if (OP2_TYPE == IS_CONST) {
ZVAL_DUP(&generator->key, key);
} else if (OP2_TYPE == IS_TMP_VAR) {
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
ZVAL_COPY_VALUE(&generator->key, key);
Specialization (only IS_VAR ad IS_CV operands may be references)
2014-09-22 12:17:35 +00:00
} else if ((OP2_TYPE == IS_VAR || OP2_TYPE == IS_CV) && Z_ISREF_P(key)) {
Cleanup
2014-04-15 21:45:40 +00:00
ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
FREE_OP2_IF_VAR();
Add support for yielding keys Keys are yielded using the yield $key => $value syntax. Currently this is implemented as a statement only and not as an expression, because conflicts arise considering nesting and use in arrays: yield yield $a => $b; // could be either yield (yield $a) => $b; // or yield (yield $a => $b); Once I find some way to resolve these conflicts this should be available as an expression too. Also the key yielding code is rather copy-and-past-y for the value yielding code, so that should be factored out.
2012-05-30 00:44:06 +00:00
} else {
Specialization (only IS_VAR ad IS_CV operands may be references)
2014-09-22 12:17:35 +00:00
ZVAL_COPY_VALUE(&generator->key, key);
Fixed typo
2014-04-16 12:35:41 +00:00
if (OP2_TYPE == IS_CV) {
Specialization (only IS_VAR ad IS_CV operands may be references)
2014-09-22 12:17:35 +00:00
if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
Cleanup
2014-04-15 21:45:40 +00:00
}
Add support for yielding keys Keys are yielded using the yield $key => $value syntax. Currently this is implemented as a statement only and not as an expression, because conflicts arise considering nesting and use in arrays: yield yield $a => $b; // could be either yield (yield $a) => $b; // or yield (yield $a => $b); Once I find some way to resolve these conflicts this should be available as an expression too. Also the key yielding code is rather copy-and-past-y for the value yielding code, so that should be factored out.
2012-05-30 00:44:06 +00:00
}
master renames phase 1
2014-08-25 17:24:55 +00:00
if (Z_TYPE(generator->key) == IS_LONG
&& Z_LVAL(generator->key) > generator->largest_used_integer_key
Add auto-increment keys When no key is explicitely yielded PHP will used auto-incrementing keys as a fallback. They behave the same as with arrays, i.e. the key is the successor of the largest previously used integer key.
2012-05-30 03:05:49 +00:00
) {
master renames phase 1
2014-08-25 17:24:55 +00:00
generator->largest_used_integer_key = Z_LVAL(generator->key);
Add auto-increment keys When no key is explicitely yielded PHP will used auto-incrementing keys as a fallback. They behave the same as with arrays, i.e. the key is the successor of the largest previously used integer key.
2012-05-30 03:05:49 +00:00
}
Add support for yielding keys Keys are yielded using the yield $key => $value syntax. Currently this is implemented as a statement only and not as an expression, because conflicts arise considering nesting and use in arrays: yield yield $a => $b; // could be either yield (yield $a) => $b; // or yield (yield $a => $b); Once I find some way to resolve these conflicts this should be available as an expression too. Also the key yielding code is rather copy-and-past-y for the value yielding code, so that should be factored out.
2012-05-30 00:44:06 +00:00
} else {
Add auto-increment keys When no key is explicitely yielded PHP will used auto-incrementing keys as a fallback. They behave the same as with arrays, i.e. the key is the successor of the largest previously used integer key.
2012-05-30 03:05:49 +00:00
/* If no key was specified we use auto-increment keys */
generator->largest_used_integer_key++;
master renames phase 1
2014-08-25 17:24:55 +00:00
ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
Add support for yielding keys Keys are yielded using the yield $key => $value syntax. Currently this is implemented as a statement only and not as an expression, because conflicts arise considering nesting and use in arrays: yield yield $a => $b; // could be either yield (yield $a) => $b; // or yield (yield $a => $b); Once I find some way to resolve these conflicts this should be available as an expression too. Also the key yielding code is rather copy-and-past-y for the value yielding code, so that should be factored out.
2012-05-30 00:44:06 +00:00
}
Fixed bug #66041: list() fails to unpack yielded ArrayAccess object Yield return values now use IS_VAR rather than IS_TMP_VAR. This fixes the issue with list() and should also be faster as it avoids doing a zval copy.
2013-11-30 12:05:40 +00:00
if (RETURN_VALUE_USED(opline)) {
/* If the return value of yield is used set the send
* target and initialize it to NULL */
Use better data structures (incomplete) - refactored return_value handling
2014-02-12 10:29:51 +00:00
generator->send_target = EX_VAR(opline->result.var);
ZVAL_NULL(generator->send_target);
Fixed bug #66041: list() fails to unpack yielded ArrayAccess object Yield return values now use IS_VAR rather than IS_TMP_VAR. This fixes the issue with list() and should also be faster as it avoids doing a zval copy.
2013-11-30 12:05:40 +00:00
} else {
generator->send_target = NULL;
}
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
Remove asterix modifier (*) for generators Generators are now automatically detected by the presence of a `yield` expression in their body. This removes the ZEND_SUSPEND_AND_RETURN_GENERATOR opcode. Instead additional checks for ZEND_ACC_GENERATOR are added to the fcall_common helper and zend_call_function. This also adds a new function zend_generator_create_zval, which handles the actual creation of the generator zval from an op array. I feel like I should deglobalize the zend_create_execute_data_from_op_array code a bit. It currently changes EG(current_execute_data) and EG(opline_ptr) which is somewhat confusing (given the name).
2012-07-19 22:49:50 +00:00
/* We increment to the next op, so we are at the correct position when the
* generator is resumed. */
ZEND_VM_INC_OPCODE();
Make the GOTO and SWITCH VMs work again
2012-05-29 00:31:56 +00:00
/* The GOTO VM uses a local opline variable. We need to set the opline
* variable in execute_data so we don't resume at an old position. */
SAVE_OPLINE();
Add YIELD opcode implementation
2012-05-26 20:44:53 +00:00
ZEND_VM_RETURN();
}
An exception thrown in try or catch block is disacarded by return statement in finally block.
2012-12-12 22:48:51 +00:00
ZEND_VM_HANDLER(159, ZEND_DISCARD_EXCEPTION, ANY, ANY)
{
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
USE_OPLINE
zval *fast_call = EX_VAR(opline->op1.var);
trailing whitespace removal
2015-01-03 09:22:58 +00:00
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
/* check for delayed exception */
if (Z_OBJ_P(fast_call) != NULL) {
Executor cleanup: fix GOTO and SWITCH VMs, remove aility to build additional PHP-5.0 compatible VM, hide executor implementation details.
2015-03-12 17:39:04 +00:00
SAVE_OPLINE();
An exception thrown in try or catch block is disacarded by return statement in finally block.
2012-12-12 22:48:51 +00:00
/* discard the previously thrown exception */
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
OBJ_RELEASE(Z_OBJ_P(fast_call));
Z_OBJ_P(fast_call) = NULL;
An exception thrown in try or catch block is disacarded by return statement in finally block.
2012-12-12 22:48:51 +00:00
}
ZEND_VM_NEXT_OPCODE();
}
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
ZEND_VM_HANDLER(162, ZEND_FAST_CALL, ANY, ANY)
{
USE_OPLINE
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
zval *fast_call = EX_VAR(opline->result.var);
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
Improve fix for #66608
2014-07-19 09:19:01 +00:00
if ((opline->extended_value & ZEND_FAST_CALL_FROM_CATCH) &&
fix bug #49348 - issue notice on get_property_ptr_ptr when used for read
2013-02-19 04:56:02 +00:00
UNEXPECTED(EG(prev_exception) != NULL)) {
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
/* in case of unhandled exception jump to catch block instead of finally */
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->op2.opline_num]);
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
ZEND_VM_CONTINUE();
}
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
/* set no delayed exception */
Z_OBJ_P(fast_call) = NULL;
/* set return address */
fast_call->u2.lineno = opline - EX(func)->op_array.opcodes;
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op1));
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
ZEND_VM_CONTINUE();
}
ZEND_VM_HANDLER(163, ZEND_FAST_RET, ANY, ANY)
{
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
USE_OPLINE
zval *fast_call = EX_VAR(opline->op1.var);
if (fast_call->u2.lineno != (uint32_t)-1) {
const zend_op *fast_ret = EX(func)->op_array.opcodes + fast_call->u2.lineno;
ZEND_VM_SET_OPCODE(fast_ret + 1);
if (fast_ret->extended_value & ZEND_FAST_CALL_FROM_FINALLY) {
fast_call->u2.lineno = fast_ret->op2.opline_num;
Fixed bug #66608 (Incorrect behavior with nested "finally" blocks)
2014-07-18 07:45:31 +00:00
}
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
ZEND_VM_CONTINUE();
} else {
/* special case for unhandled exceptions */
USE_OPLINE
if (opline->extended_value == ZEND_FAST_RET_TO_FINALLY) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->op2.opline_num]);
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
ZEND_VM_CONTINUE();
} else {
Changed "finally" handling. Removed EX(fast_ret) and EX(delayed_exception). Allocate and use additional IS_TMP_VAR slot on VM stack instead.
2014-11-27 06:56:43 +00:00
EG(exception) = Z_OBJ_P(fast_call);
Z_OBJ_P(fast_call) = NULL;
Fixed bug #65784 (Segfault with finally).
2013-12-12 16:15:50 +00:00
if (opline->extended_value == ZEND_FAST_RET_TO_CATCH) {
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->op2.opline_num]);
Fixed bug #65784 (Segfault with finally).
2013-12-12 16:15:50 +00:00
ZEND_VM_CONTINUE();
Refactored parameter passing mechanism. In PHP-5.6 and below each argument passed to user function was copies on VM stack twice. Now we always have ZEND_INIT_FCALL (or simular) opcode that pushes "call frame" on top of VM stack. "Call frame" is actually the same zend_execute_data structure. All the following ZEND_SEND instructions push arguments on top of the stack in a way that they directly comes into corresponding CV variables of the called frame. Extra arguments are copied at the end of stack frame (after all CV and TMP variables) on function enterance. There are two minor incompatibilities: 1) It's not allowed to decalre functions redefining arguments e.g. "function foo($a,$a) {}". 2) func_get_arg() and func_get args() return the current value of argument and not the original value that was sent.
2014-06-30 11:43:45 +00:00
} else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_GENERATOR) != 0)) {
Implement Generator::getReturn() Conflicts: Zend/zend_vm_execute.h
2015-02-19 19:17:37 +00:00
/* The generator object is stored in EX(return_value) */
zend_generator *generator = (zend_generator *) EX(return_value);
zend_generator_close(generator, 1);
ZEND_VM_RETURN();
Fixed bug #65784 (Segfault with finally).
2013-12-12 16:15:50 +00:00
} else {
ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
}
Improved "finally" im[plementation
2012-11-22 11:17:05 +00:00
}
}
}
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
ZEND_VM_HANDLER(166, ZEND_POW, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
add T_POW (**) operator Fixed recognition of the operator Added opcode, still doing multiply instead of pow() opcode now always returns int(42) The right answer, but always a float Yanked code from pow() implementation. Should not handle negative long as exponent ourselves Added test cases from pow() Moved precedence higher than '~' Added GMP operator overloading Added ZEND_ASSIGN_POW (**=) operator. Added pow() as a language construct. Adjusted test cases for changed precedence. Reduced pow() to shell function around ZEND_API pow_function() Reduced test case to only contain edge cases Added overloading test case Moved unary minus above T_POW Revert "Added pow() as a language construct." Bad bad bad idea. This reverts commit f60b98cf7a8371233d800a6faa286ddba4432d02. Reverted unary minus behaviour due to previous revert. Convert arrays to int(0) Exponent with array as a base becomes int(0) Rebase against master Fixed tokenizer test case
2013-11-19 07:36:06 +00:00
{
USE_OPLINE
zend_free_op free_op1, free_op2;
SAVE_OPLINE();
Merge mainstream 'master' branch into refactoring During merge I had to revert: Nikita's patch for php_splice() (it probably needs to be applyed again) Bob Weinand's patches related to constant expression handling (we need to review them carefully) I also reverted all our attempts to support sapi/phpdbg (we didn't test it anyway) Conflicts: Zend/zend.h Zend/zend_API.c Zend/zend_ast.c Zend/zend_compile.c Zend/zend_compile.h Zend/zend_constants.c Zend/zend_exceptions.c Zend/zend_execute.c Zend/zend_execute.h Zend/zend_execute_API.c Zend/zend_hash.c Zend/zend_highlight.c Zend/zend_language_parser.y Zend/zend_language_scanner.c Zend/zend_language_scanner_defs.h Zend/zend_variables.c Zend/zend_vm_def.h Zend/zend_vm_execute.h ext/date/php_date.c ext/dom/documenttype.c ext/hash/hash.c ext/iconv/iconv.c ext/mbstring/tests/zend_multibyte-10.phpt ext/mbstring/tests/zend_multibyte-11.phpt ext/mbstring/tests/zend_multibyte-12.phpt ext/mysql/php_mysql.c ext/mysqli/mysqli.c ext/mysqlnd/mysqlnd_reverse_api.c ext/mysqlnd/php_mysqlnd.c ext/opcache/ZendAccelerator.c ext/opcache/zend_accelerator_util_funcs.c ext/opcache/zend_persist.c ext/opcache/zend_persist_calc.c ext/pcre/php_pcre.c ext/pdo/pdo_dbh.c ext/pdo/pdo_stmt.c ext/pdo_pgsql/pgsql_driver.c ext/pgsql/pgsql.c ext/reflection/php_reflection.c ext/session/session.c ext/spl/spl_array.c ext/spl/spl_observer.c ext/standard/array.c ext/standard/basic_functions.c ext/standard/html.c ext/standard/mail.c ext/standard/php_array.h ext/standard/proc_open.c ext/standard/streamsfuncs.c ext/standard/user_filters.c ext/standard/var_unserializer.c ext/standard/var_unserializer.re main/php_variables.c sapi/phpdbg/phpdbg.c sapi/phpdbg/phpdbg_bp.c sapi/phpdbg/phpdbg_frame.c sapi/phpdbg/phpdbg_help.c sapi/phpdbg/phpdbg_list.c sapi/phpdbg/phpdbg_print.c sapi/phpdbg/phpdbg_prompt.c
2014-04-25 20:32:51 +00:00
pow_function(EX_VAR(opline->result.var),
Move checks for references into slow paths of operator functions. Remove duplicate opcode handlers.
2014-12-05 23:14:45 +00:00
GET_OP1_ZVAL_PTR(BP_VAR_R),
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
GET_OP2_ZVAL_PTR(BP_VAR_R));
add T_POW (**) operator Fixed recognition of the operator Added opcode, still doing multiply instead of pow() opcode now always returns int(42) The right answer, but always a float Yanked code from pow() implementation. Should not handle negative long as exponent ourselves Added test cases from pow() Moved precedence higher than '~' Added GMP operator overloading Added ZEND_ASSIGN_POW (**=) operator. Added pow() as a language construct. Adjusted test cases for changed precedence. Reduced pow() to shell function around ZEND_API pow_function() Reduced test case to only contain edge cases Added overloading test case Moved unary minus above T_POW Revert "Added pow() as a language construct." Bad bad bad idea. This reverts commit f60b98cf7a8371233d800a6faa286ddba4432d02. Reverted unary minus behaviour due to previous revert. Convert arrays to int(0) Exponent with array as a base becomes int(0) Rebase against master Fixed tokenizer test case
2013-11-19 07:36:06 +00:00
FREE_OP1();
FREE_OP2();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Removed useless handlers
2014-12-06 00:03:48 +00:00
ZEND_VM_HANDLER(167, ZEND_ASSIGN_POW, VAR|CV, CONST|TMPVAR|CV)
add T_POW (**) operator Fixed recognition of the operator Added opcode, still doing multiply instead of pow() opcode now always returns int(42) The right answer, but always a float Yanked code from pow() implementation. Should not handle negative long as exponent ourselves Added test cases from pow() Moved precedence higher than '~' Added GMP operator overloading Added ZEND_ASSIGN_POW (**=) operator. Added pow() as a language construct. Adjusted test cases for changed precedence. Reduced pow() to shell function around ZEND_API pow_function() Reduced test case to only contain edge cases Added overloading test case Moved unary minus above T_POW Revert "Added pow() as a language construct." Bad bad bad idea. This reverts commit f60b98cf7a8371233d800a6faa286ddba4432d02. Reverted unary minus behaviour due to previous revert. Convert arrays to int(0) Exponent with array as a base becomes int(0) Rebase against master Fixed tokenizer test case
2013-11-19 07:36:06 +00:00
{
ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op,pow_function);
}
Introduced new BIND_GLOBAL instraction instead of FETCH_W+ASSIGN_REF pair that caused a lot of useles checks
2014-06-06 11:04:30 +00:00
ZEND_VM_HANDLER(168, ZEND_BIND_GLOBAL, CV, CONST)
{
USE_OPLINE
zend_free_op free_op1, free_op2;
zval *varname;
zval *value;
zval *variable_ptr;
Use runtime-cache to avoid hash lookups in BIND_GLOBAL instruction
2014-09-16 20:52:45 +00:00
uint32_t idx;
Introduced new BIND_GLOBAL instraction instead of FETCH_W+ASSIGN_REF pair that caused a lot of useles checks
2014-06-06 11:04:30 +00:00
SAVE_OPLINE();
varname = GET_OP2_ZVAL_PTR(BP_VAR_R);
trailing whitespace removal
2015-01-03 09:22:58 +00:00
Micro optimization
2014-11-24 12:46:34 +00:00
/* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
idx = (uint32_t)(uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(varname)) - 1;
Merged zend_array and HashTable into the single data structure. Now each HashTable is also zend_array, so it's refcounted and may be a subject for Copy on Write zend_array_dup() was changed to allocate and return HashTable, instead of taking preallocated HashTable as argument.
2015-02-13 19:20:39 +00:00
if (EXPECTED(idx < EG(symbol_table).nNumUsed)) {
Bucket *p = EG(symbol_table).arData + idx;
Micro optimization
2014-11-24 12:46:34 +00:00
if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
(EXPECTED(p->key == Z_STR_P(varname)) ||
(EXPECTED(p->h == Z_STR_P(varname)->h) &&
EXPECTED(p->key != NULL) &&
EXPECTED(p->key->len == Z_STRLEN_P(varname)) &&
EXPECTED(memcmp(p->key->val, Z_STRVAL_P(varname), Z_STRLEN_P(varname)) == 0)))) {
trailing whitespace removal
2015-01-03 09:22:58 +00:00
Merged zend_array and HashTable into the single data structure. Now each HashTable is also zend_array, so it's refcounted and may be a subject for Copy on Write zend_array_dup() was changed to allocate and return HashTable, instead of taking preallocated HashTable as argument.
2015-02-13 19:20:39 +00:00
value = &EG(symbol_table).arData[idx].val;
Micro optimization
2014-11-24 12:46:34 +00:00
ZEND_VM_C_GOTO(check_indirect);
}
}
Merged zend_array and HashTable into the single data structure. Now each HashTable is also zend_array, so it's refcounted and may be a subject for Copy on Write zend_array_dup() was changed to allocate and return HashTable, instead of taking preallocated HashTable as argument.
2015-02-13 19:20:39 +00:00
value = zend_hash_find(&EG(symbol_table), Z_STR_P(varname));
Micro optimization
2014-11-24 12:46:34 +00:00
if (UNEXPECTED(value == NULL)) {
Merged zend_array and HashTable into the single data structure. Now each HashTable is also zend_array, so it's refcounted and may be a subject for Copy on Write zend_array_dup() was changed to allocate and return HashTable, instead of taking preallocated HashTable as argument.
2015-02-13 19:20:39 +00:00
value = zend_hash_add_new(&EG(symbol_table), Z_STR_P(varname), &EG(uninitialized_zval));
idx = ((char*)value - (char*)EG(symbol_table).arData) / sizeof(Bucket);
Micro optimization
2014-11-24 12:46:34 +00:00
/* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(uintptr_t)(idx + 1));
} else {
Merged zend_array and HashTable into the single data structure. Now each HashTable is also zend_array, so it's refcounted and may be a subject for Copy on Write zend_array_dup() was changed to allocate and return HashTable, instead of taking preallocated HashTable as argument.
2015-02-13 19:20:39 +00:00
idx = ((char*)value - (char*)EG(symbol_table).arData) / sizeof(Bucket);
Micro optimization
2014-11-24 12:46:34 +00:00
/* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(uintptr_t)(idx + 1));
ZEND_VM_C_LABEL(check_indirect):
Introduced new BIND_GLOBAL instraction instead of FETCH_W+ASSIGN_REF pair that caused a lot of useles checks
2014-06-06 11:04:30 +00:00
/* GLOBAL variable may be an INDIRECT pointer to CV */
Use runtime-cache to avoid hash lookups in BIND_GLOBAL instruction
2014-09-16 20:52:45 +00:00
if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
value = Z_INDIRECT_P(value);
if (UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
ZVAL_NULL(value);
}
}
Introduced new BIND_GLOBAL instraction instead of FETCH_W+ASSIGN_REF pair that caused a lot of useles checks
2014-06-06 11:04:30 +00:00
}
variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_assign_to_variable_reference(variable_ptr, value);
Introduced new BIND_GLOBAL instraction instead of FETCH_W+ASSIGN_REF pair that caused a lot of useles checks
2014-06-06 11:04:30 +00:00
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
ZEND_VM_HANDLER(121, ZEND_STRLEN, CONST|TMPVAR|CV, ANY)
Implemented builtin instruction for strlen()
2014-07-11 14:52:27 +00:00
{
USE_OPLINE
zval *value;
zend_free_op free_op1;
SAVE_OPLINE();
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
ZEND_VM_C_LABEL(try_strlen):
Implemented builtin instruction for strlen()
2014-07-11 14:52:27 +00:00
if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
master renames phase 1
2014-08-25 17:24:55 +00:00
ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
} else {
zend_bool strict;
Get rid of few more duplicate handlers
2014-12-05 15:23:39 +00:00
if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
value = Z_REFVAL_P(value);
ZEND_VM_C_GOTO(try_strlen);
Implemented builtin instruction for strlen()
2014-07-11 14:52:27 +00:00
}
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
strict = EX_USES_STRICT_TYPES();
do {
if (EXPECTED(!strict)) {
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-20 20:18:52 +00:00
zend_string *str;
zval tmp;
ZVAL_COPY(&tmp, value);
if (zend_parse_arg_str_weak(&tmp, &str)) {
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
ZVAL_LONG(EX_VAR(opline->result.var), str->len);
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-20 20:18:52 +00:00
zval_ptr_dtor(&tmp);
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
break;
}
ZPP changed to lazely check for "strict/weak" only if it's really necessary. Cleanup.
2015-03-20 20:18:52 +00:00
zval_ptr_dtor(&tmp);
Improved type hinting: EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore) Standerd ZPP is called from VM only for weak type check or strict exception (int -> double) Fixed ZEND_RECV_VARIADIC Fixed ZEND_STRLEN TODO: should we accept IS_NULL for non-nullable arguments?
2015-03-20 13:04:04 +00:00
}
zend_internal_type_error(strict, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
ZVAL_NULL(EX_VAR(opline->result.var));
} while (0);
Implemented builtin instruction for strlen()
2014-07-11 14:52:27 +00:00
}
FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Implemented builtin instruction for type check functions - is_*()
2014-07-14 06:33:11 +00:00
ZEND_VM_HANDLER(123, ZEND_TYPE_CHECK, CONST|TMP|VAR|CV, ANY)
{
USE_OPLINE
zval *value;
zend_free_op free_op1;
SAVE_OPLINE();
value = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
switch (opline->extended_value) {
case IS_NULL:
master renames phase 1
2014-08-25 17:24:55 +00:00
case IS_LONG:
Implemented builtin instruction for type check functions - is_*()
2014-07-14 06:33:11 +00:00
case IS_DOUBLE:
case IS_STRING:
case IS_ARRAY:
ZVAL_BOOL(EX_VAR(opline->result.var), Z_TYPE_P(value) == opline->extended_value);
break;
case _IS_BOOL:
ZVAL_BOOL(EX_VAR(opline->result.var), Z_TYPE_P(value) == IS_TRUE || Z_TYPE_P(value) == IS_FALSE);
break;
case IS_OBJECT:
if (Z_TYPE_P(value) == opline->extended_value) {
Remove support for classes without class entries get_class_entry must be non-NULL and return non-NULL.
2014-10-09 11:58:14 +00:00
zend_class_entry *ce = Z_OBJCE_P(value);
trailing whitespace removal
2015-01-03 09:22:58 +00:00
if (ce->name->len == sizeof("__PHP_Incomplete_Class") - 1
Use memcmp() instead of strncmp()
2015-03-16 12:53:54 +00:00
&& !memcmp(ce->name->val, "__PHP_Incomplete_Class", sizeof("__PHP_Incomplete_Class") - 1)) {
Remove support for classes without class entries get_class_entry must be non-NULL and return non-NULL.
2014-10-09 11:58:14 +00:00
ZVAL_FALSE(EX_VAR(opline->result.var));
Implemented builtin instruction for type check functions - is_*()
2014-07-14 06:33:11 +00:00
} else {
Remove support for classes without class entries get_class_entry must be non-NULL and return non-NULL.
2014-10-09 11:58:14 +00:00
ZVAL_TRUE(EX_VAR(opline->result.var));
Implemented builtin instruction for type check functions - is_*()
2014-07-14 06:33:11 +00:00
}
} else {
ZVAL_FALSE(EX_VAR(opline->result.var));
}
break;
case IS_RESOURCE:
if (Z_TYPE_P(value) == opline->extended_value) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(value));
Implemented builtin instruction for type check functions - is_*()
2014-07-14 06:33:11 +00:00
ZVAL_BOOL(EX_VAR(opline->result.var), type_name != NULL);
} else {
ZVAL_FALSE(EX_VAR(opline->result.var));
}
Implement ZEND_TYPE_CHECK optimization
2014-07-22 21:11:12 +00:00
break;
Implemented builtin instruction for type check functions - is_*()
2014-07-14 06:33:11 +00:00
EMPTY_SWITCH_DEFAULT_CASE()
}
FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Implemented builtin instruction for strlen()
2014-07-14 11:43:11 +00:00
ZEND_VM_HANDLER(122, ZEND_DEFINED, CONST, ANY)
{
USE_OPLINE
zend_constant *c;
SAVE_OPLINE();
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) {
Implemented builtin instruction for strlen()
2014-07-14 11:43:11 +00:00
ZVAL_TRUE(EX_VAR(opline->result.var));
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
} else if ((c = zend_quick_get_constant(EX_CONSTANT(opline->op1), 0)) == NULL) {
Implemented builtin instruction for strlen()
2014-07-14 11:43:11 +00:00
ZVAL_FALSE(EX_VAR(opline->result.var));
} else {
Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same.
2014-12-12 07:19:41 +00:00
CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), c);
Implemented builtin instruction for strlen()
2014-07-14 11:43:11 +00:00
ZVAL_TRUE(EX_VAR(opline->result.var));
}
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
Improved assert() according to expectations RFC. See https://wiki.php.net/rfc/expectations Squashed commit of the following: commit 3f3651a7870738e35ec541e53b53069152135b24 Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Mar 2 11:56:33 2015 +0300 opcode 137 is used for ZEND_OP_DATA and con't be reused for ZEND_ASSERT_CHECK commit ca8ecabf2a5f97f9116839c33396c9a7037e4368 Merge: 24328ac 9dac923 Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Mar 2 10:49:23 2015 +0300 Merge branch 'master' into assert * master: Update NEWS Fixed bug #69139 (Crash in gc_zval_possible_root on unserialize) windows only test Align entries format Align entries format for 5.6.7 Align entries format for 5.5.23 Bump header year Fixed bug #69144 (strtr not replacing with partly matching replace pairs) Fixed test? Revert mktime()/gmmktime()'s arginfo Update NEWS Fixed bug #69141 Missing arguments in reflection info for some builtin functions Add NEWS entry Remove useless date warning Fix ARG_INFO for levenshtein Fix ARG_INFO for levenshtein fix dir separator in tests Update NEWS Fixed bug #69085 (SoapClient's __call() type confusion through unserialize()). commit 24328ac03f79a0f3b19be7411bf9e173f392abda Merge: 021fd94 1cdee9a Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Feb 27 15:57:13 2015 +0300 Merge branch 'master' into assert * master: Fixed C++ support Fixed bug #69115 crash in mail Reorder Update NEWs Fixed bug #69121 (Segfault in get_current_user when script owner is not in passwd with ZTS build) Update News Fixed bug #69125 (Array numeric string as key) fix bug#68942's patch Fixed ability to build unspecialized executor Fixed bug #69124 (method name could not be used when by ref) Fixed a bug that header value is not terminated by '\0' when accessed through getenv(). Fixed a bug that header value is not terminated by '\0' when accessed through getenv(). commit 021fd94ed1d692d212e6e30c6c1a9767c3f16f7f Merge: 49963eb ace1f82 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Feb 26 11:26:03 2015 +0300 Merge branch 'master' into assert * master: (59 commits) Improved ASSIGN_DIM handler Don't inline slow path Revert a part committted by mistake Fixed compilation warnings Fixed a bug that header value is not terminated by '\0' when accessed through getenv(). better name Improve fix for #69038 Update NEWs Fixed bug #69108 ("Segmentation fault" when (de)serializing SplObjectStorage) Added specialized versions of DO_FCALL handler: DO_ICALL - for internal functions DO_UCALL - for user functions DO_FCALL_BY_NAME - plain, most probably user, funcstions (not methods) Use cache_slot offsets instead of indexes (simplify run-time instructions) Split INIT_FCALL_BY_NAME inti INIT_FCALL_BY_NAME(CONST+STRING) and INIT_DYNAMIC_CALL(CONST-STRING|TMPVAR|CV) Support list($a, $b) = $a Avoid unnecassary check Make zend_array_destroy() to free the corresponding zend_array Eliminate check on the fast path Make current() and key() receive argument by value. Use Firebird default home folder, replace Interbase with Firebird Updated NEWS updated NEWS ... Conflicts: Zend/zend_vm_execute.h Zend/zend_vm_opcodes.c Zend/zend_vm_opcodes.h commit 49963ebf9d2bcd6d2670203dd72884f6ba6c8a4b Merge: 07b1f92 6b77959 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Feb 19 11:13:08 2015 +0300 Merge branch 'master' into assert * master: Implemented AST pretty-printer update NEWS to match the actual stuff in 5.6.6 update NEWS to match the actual stuff in 5.5.22 update NEWS(add missing entry for the enchant fix, and reorder the entries a bit) fix typo in bug# update NEWS fix email format update NEWS update 5.6.6 release date in NEWS Fix bug #69033 (Request may get env. variables from previous requests if PHP works as FastCGI) BFN fix test fix test fix test Fixed bug #65593 (Segfault when calling ob_start from output buffering callback) Updated NEWS add CVE 5.4.39 next Fix associativity to match Perl Blast off to space. Conflicts: Zend/zend_ast.c commit 07b1f92ed662f6fa9309e679b83aff328362c98b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Feb 18 23:06:32 2015 +0300 fixed pretty-printer (support for "elseif") commit 5a976c8d85078502b48379996ab066e57533a0c3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Feb 18 19:50:08 2015 +0300 Fixed vaeious ptetty-printer issues commit 69491e8e8e692030b0585aab485146906c0fedaf Merge: 8473157 3ddc246 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Feb 18 10:18:32 2015 +0300 Merge branch 'master' into assert * master: Set PHP_JSON_VERSION to 1.4.0 Remove unnecessary resource checks in openssl ext JSON is now maintained commit 8473157fbb12d03fff8d5b602865a4b667522a4d Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Feb 18 10:17:26 2015 +0300 Fixed typo and white spaces commit 96de5ffc8d604df9797d0141ae5ad9c15e1d6c32 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Feb 18 00:28:39 2015 +0300 Fixed assert() in namesapaces commit 5eba069c28e7b6590618707e0b21cdb2dd62a192 Merge: 4a2d9c0 d428bf2 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Feb 17 22:45:55 2015 +0300 Merge branch 'master' into assert * master: (25 commits) improve debugability in TS debug builds More UPGRADING, in particular on foreach Fixed bug #69038 (switch(SOMECONSTANT) misbehaves) for master Replace var is introduced abstain from using xmlCleanupParser fix TS build Fix bug #68942 (Use after free vulnerability in unserialize() with DateTimeZone) update news Fix bug #68942 (Use after free vulnerability in unserialize() with DateTimeZone) Port for for bug #68552 Fix bug #68942 (Use after free vulnerability in unserialize() with DateTimeZone) Update NEWS Fixed bug #69038 (switch(SOMECONSTANT) misbehaves) - BFN Don't read the local php.ini when Generating Phar When building phar shared, you can end up loading a previous phar.so that isn't compatible with the php cli being used to generate Phar here. - Fixed bug #67827 (broken detection of system crypt sha256/sha512 support) Delete json outdated package.xml made ZEND_TSRMLS_CACHE_* macros look like function calls - Fix merge - Fixed bug #67427 (SoapServer cannot handle large messages) patch by: brandt at docoloc dot de ... commit 4a2d9c0953dccd9e78ebee9291e1213419eb9136 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Feb 17 22:45:10 2015 +0300 Implemented AST pretty-printer to capture expression passed to assert() commit 7a059b66d51a65159801bd826346721325b89fec Merge: 9973df7 3892eba Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Feb 16 18:42:28 2015 +0300 Merge branch 'expect' of github.com:krakjoe/php-src into assert * 'expect' of github.com:krakjoe/php-src: import expect Conflicts: Zend/zend_compile.c Zend/zend_execute_API.c Zend/zend_globals.h Zend/zend_vm_def.h Zend/zend_vm_execute.h Zend/zend_vm_opcodes.c Zend/zend_vm_opcodes.h ext/opcache/Optimizer/block_pass.c ext/opcache/Optimizer/pass1_5.c ext/standard/assert.c ext/standard/tests/assert/assert_error3.phpt commit 3892eba2bf56a7699453855c995404106322718d Author: krakjoe <joe.watkins@live.co.uk> Date: Sun Feb 2 12:49:35 2014 +0000 import expect
2015-03-02 09:25:40 +00:00
ZEND_VM_HANDLER(151, ZEND_ASSERT_CHECK, ANY, ANY)
{
USE_OPLINE
if (EG(assertions) <= 0) {
zend_op *target = OP_JMP_ADDR(opline, opline->op2);
if (RETURN_VALUE_USED(target-1)) {
ZVAL_TRUE(EX_VAR((target-1)->result.var));
}
ZEND_VM_JMP(target);
} else {
ZEND_VM_NEXT_OPCODE();
}
}
Better make this be consistent with DO_ICALL/DO_CALL Revert "Use more specific op type" This reverts commit 9b07ed6dcc6f0f77fa75ee6a5c2b21298b87f509.
2015-03-18 14:09:57 +00:00
ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, ANY, ANY)
Reimplemented special constant handling. Now __HALT_COMPILER_OFFSET__ is resolved at compile-time. __CLASS__ retrived using separate ZEND_FETCH_CLASS_NAME opcode.
2015-03-18 12:31:29 +00:00
{
USE_OPLINE
if (EG(scope) && EG(scope)->name) {
ZVAL_STR_COPY(EX_VAR(opline->result.var), EG(scope)->name);
} else {
ZVAL_EMPTY_STRING(EX_VAR(opline->result.var));
}
ZEND_VM_NEXT_OPCODE();
Fixed white spaces
2015-03-20 08:10:29 +00:00
}
Reference in New Issue Copy Permalink