diff options
218 files changed, 7810 insertions, 5363 deletions
@@ -3,6 +3,8 @@ PHP NEWS ?? ??? 2016, PHP 7.1.0 - Core: + . Implemented safe execution timeout handling, that prevents rundom crashes + after "Maximum execution time exceeded" error. (Dmitry) . Fixed bug #62210 (Exceptions can leak temporary variables). (Dmitry, Bob) . Fixed bug #62814 (It is possible to stiffen child class members visibility). (Nikita) @@ -20,11 +22,17 @@ PHP NEWS . (int), intval() where $base is 10 or unspecified, settype(), decbin(), decoct(), dechex(), integer operators and other conversions now always respect scientific notation in numeric strings. (Andrea) + . Implemented the RFC `Catching multiple exception types`. (Bronislaw Bialek, + Pierrick) - FTP: . Implemented FR #55651 (Option to ignore the returned FTP PASV address). (abrender at elitehosts dot com) +- Intl: + . Added IntlTimeZone::getWindowsID() and + IntlTimeZone::getIDForWindowsID(). (Sara) + - Hash: . Added SHA3 fixed mode algorithms (224, 256, 384, and 512 bit). (Sara) @@ -64,5 +72,6 @@ PHP NEWS . Implemented FR #69359 (Provide a way to fetch the current environment variables). (Ferenc) . unpack() function accepts an additional optional argument $offset. (Dmitry) + . Implemented #51879 stream context socket option tcp_nodelay (Joe) <<< NOTE: Insert NEWS from last stable release here prior to actual release! >>> diff --git a/Zend/tests/arg_unpack/by_ref_separation.phpt b/Zend/tests/arg_unpack/by_ref_separation.phpt new file mode 100644 index 0000000000..b52c28168a --- /dev/null +++ b/Zend/tests/arg_unpack/by_ref_separation.phpt @@ -0,0 +1,36 @@ +--TEST-- +Array must be separated if unpacking by reference +--FILE-- +<?php + +function inc(&... $args) { + foreach ($args as &$arg) { + $arg++; + } +} + +$arr = [1, 2]; +$arr[] = 3; +$arr2 = $arr; +inc(...$arr); +var_dump($arr); +var_dump($arr2); + +?> +--EXPECT-- +array(3) { + [0]=> + int(2) + [1]=> + int(3) + [2]=> + int(4) +} +array(3) { + [0]=> + int(1) + [1]=> + int(2) + [2]=> + int(3) +} diff --git a/Zend/tests/bug34617.phpt b/Zend/tests/bug34617.phpt index 25f785f909..ded1aec2fd 100644 --- a/Zend/tests/bug34617.phpt +++ b/Zend/tests/bug34617.phpt @@ -8,7 +8,8 @@ class Thing {} function boom() { $reader = xml_parser_create(); - xml_set_object($reader, new Thing()); + $thing = new Thing(); + xml_set_object($reader, $thing); die("ok\n"); xml_parser_free($reader); } diff --git a/Zend/tests/bug41117_1.phpt b/Zend/tests/bug41117_1.phpt index f555b637ad..a612f07fed 100644 --- a/Zend/tests/bug41117_1.phpt +++ b/Zend/tests/bug41117_1.phpt @@ -10,5 +10,4 @@ class foo { $obj = new foo("Hello world"); ?> --EXPECTF-- -Fatal error: Cannot re-assign $this in %sbug41117_1.php on line 3 - +Fatal error: Cannot use $this as parameter in %s on line %d diff --git a/Zend/tests/bug71428.1.phpt b/Zend/tests/bug71428.1.phpt index b754687560..fbf342380f 100644 --- a/Zend/tests/bug71428.1.phpt +++ b/Zend/tests/bug71428.1.phpt @@ -1,5 +1,7 @@ --TEST-- bug #71428.1: inheritance with null default values +--XFAIL-- +This is a BC break --FILE-- <?php class A { diff --git a/Zend/tests/bug71428.2.phpt b/Zend/tests/bug71428.2.phpt index 3d8b257a16..9a98ba7760 100644 --- a/Zend/tests/bug71428.2.phpt +++ b/Zend/tests/bug71428.2.phpt @@ -1,7 +1,7 @@ --TEST-- bug #71428.2: inheritance of ye olde dynamic interfaces --SKIPIF-- -<?php if (!extension_loaded('pdo')) ?> +<?php if (!extension_loaded('pdo')) die("skip PDO is not available"); ?> --FILE-- <?php interface StatementInterface { diff --git a/Zend/tests/bug71428.3.phpt b/Zend/tests/bug71428.3.phpt index 2f400e5952..65d397052e 100644 --- a/Zend/tests/bug71428.3.phpt +++ b/Zend/tests/bug71428.3.phpt @@ -1,5 +1,7 @@ --TEST-- bug #71428: Validation type inheritance with = NULL +--XFAIL-- +This is a BC break --FILE-- <?php class A { } diff --git a/Zend/tests/bug71737.phpt b/Zend/tests/bug71737.phpt new file mode 100644 index 0000000000..b44de8e78e --- /dev/null +++ b/Zend/tests/bug71737.phpt @@ -0,0 +1,16 @@ +--TEST-- +Bug #71737: Memory leak in closure with parameter named $this +--FILE-- +<?php + +class Test { + public function method() { + return function($this) {}; + } +} + +(new Test)->method()(new stdClass); + +?> +--EXPECTF-- +Fatal error: Cannot use $this as parameter in %s on line %d diff --git a/Zend/tests/bug72038.phpt b/Zend/tests/bug72038.phpt new file mode 100644 index 0000000000..1e32af4c18 --- /dev/null +++ b/Zend/tests/bug72038.phpt @@ -0,0 +1,27 @@ +--TEST-- +Bug #72038 (Function calls with values to a by-ref parameter don't always throw a notice) +--FILE-- +<?php + +test($foo = new stdClass); +var_dump($foo); +test($bar = 2); +var_dump($bar); +test($baz = &$bar); +var_dump($baz); + +function test(&$param) { + $param = 1; +} + +?> +--EXPECTF-- + +Notice: Only variables should be passed by reference in %s on line %d +object(stdClass)#1 (0) { +} + +Notice: Only variables should be passed by reference in %s on line %d +int(2) +int(1) + diff --git a/Zend/tests/bug72057.phpt b/Zend/tests/bug72057.phpt new file mode 100644 index 0000000000..e1a129bbc2 --- /dev/null +++ b/Zend/tests/bug72057.phpt @@ -0,0 +1,21 @@ +--TEST-- +Bug #72057 (PHP hangs when user error handler throws exception after Notice from type coercion) +--FILE-- +<?php + +set_error_handler( + function() { + throw new Exception("My custom error"); + } +); + +(function (int $i) { bar(); })("7as"); + +--EXPECTF-- + +Fatal error: Uncaught Exception: My custom error in %s:%d +Stack trace: +#0 %s(%d): {closure}(8, 'A non well form...', '%s', %d, Array) +#1 %s(%d): {closure}('7as') +#2 {main} + thrown in %s on line %d diff --git a/Zend/tests/bug72101.phpt b/Zend/tests/bug72101.phpt new file mode 100644 index 0000000000..a04425cee4 --- /dev/null +++ b/Zend/tests/bug72101.phpt @@ -0,0 +1,85 @@ +--TEST-- +Bug #72101 (crash on complex code) +--FILE-- +<?php +class PHPUnit_Framework_MockObject_Stub_ReturnCallback { + protected $callback; + public function __construct($callback) { + $this->callback = $callback; + } + public function invoke($invocation) { + return call_user_func_array($this->callback, $invocation->parameters); + } +} + +class PHPUnit_Framework_MockObject_InvocationMocker { + protected $matchers = []; + public function addMatcher( $matcher) { + $this->matchers[] = $matcher; + } + public function invoke( $invocation) { + foreach ($this->matchers as $match) { + $match->invoked($invocation); + } + } +} + +class PHPUnit_Framework_MockObject_Matcher { + public $stub = null; + public function invoked($invocation) { + return $this->stub->invoke($invocation); + } +} + +class MethodCallbackByReference { + public function bar(&$a, &$b, $c) { + Legacy::bar($a, $b, $c); + } + public function callback(&$a, &$b, $c) { + $b = 1; + } +} +class PHPUnit_Framework_MockObject_Invocation_Static { + public $parameters; + public function __construct(array $parameters) { + $this->parameters = $parameters; + } +} + +class Mock_MethodCallbackByReference_7b180d26 extends MethodCallbackByReference { + public $inv_mocker; + public function bar(&$a, &$b, $c) { + $arguments = array($a, $b, $c); + $result = $this->inv_mocker->invoke( + new PHPUnit_Framework_MockObject_Invocation_Static( + $arguments + ) + ); + return $result; + } +} + +set_error_handler(function() { +// var_dump(func_get_args()); + DoesNotExists::$nope = true; +}, E_ALL | E_STRICT); + +$foo = new Mock_MethodCallbackByReference_7b180d26(); +$InvMocker = new PHPUnit_Framework_MockObject_InvocationMocker(); +$foo->inv_mocker = $InvMocker; +$OuterMatcher = new PHPUnit_Framework_MockObject_Matcher(); +$InvMocker->addMatcher($OuterMatcher); +$OuterMatcher->methodNameMatcher = null; +$OuterMatcher->stub = new PHPUnit_Framework_MockObject_Stub_ReturnCallback([$foo, 'callback']); +$a = $b = $c = 0; +$foo->bar($a, $b, $c); +--EXPECTF-- +Fatal error: Uncaught Error: Class 'DoesNotExists' not found in %sbug72101.php:61 +Stack trace: +#0 %sbug72101.php(8): {closure}(2, 'Parameter 1 to ...', '%s', 8, Array) +#1 %sbug72101.php(27): PHPUnit_Framework_MockObject_Stub_ReturnCallback->invoke(Object(PHPUnit_Framework_MockObject_Invocation_Static)) +#2 %sbug72101.php(19): PHPUnit_Framework_MockObject_Matcher->invoked(Object(PHPUnit_Framework_MockObject_Invocation_Static)) +#3 %sbug72101.php(51): PHPUnit_Framework_MockObject_InvocationMocker->invoke(Object(PHPUnit_Framework_MockObject_Invocation_Static)) +#4 %sbug72101.php(72): Mock_MethodCallbackByReference_7b180d26->bar(0, 0, 0) +#5 {main} + thrown in %sbug72101.php on line 61 diff --git a/Zend/tests/bug72119.phpt b/Zend/tests/bug72119.phpt new file mode 100644 index 0000000000..b8f070a25a --- /dev/null +++ b/Zend/tests/bug72119.phpt @@ -0,0 +1,18 @@ +--TEST-- +Bug #72119 (Interface declaration compatibility regression with default values) +--FILE-- +<?php +interface Foo { + public function bar(array $baz = null); +} + +class Hello implements Foo { + public function bar(array $baz = []) + { + + } +} +echo "OK\n"; +?> +--EXPECT-- +OK diff --git a/Zend/tests/call_user_func_array_prefer_ref.phpt b/Zend/tests/call_user_func_array_prefer_ref.phpt new file mode 100644 index 0000000000..d7a5fd913a --- /dev/null +++ b/Zend/tests/call_user_func_array_prefer_ref.phpt @@ -0,0 +1,73 @@ +--TEST-- +call_user_func_array() passes value to prefer-ref arg if element wasn't a reference +--FILE-- +<?php + +namespace { + call_user_func_array('array_multisort', [[3, 2, 1]]); + + $args = [[3, 2, 1]]; + call_user_func_array('array_multisort', $args); + var_dump($args); + unset($args); + + $array = [3, 2, 1]; + call_user_func('array_multisort', $array); + var_dump($array); + unset($array); +} + +namespace Foo { + call_user_func_array('array_multisort', [[3, 2, 1]]); + + $args = [[3, 2, 1]]; + call_user_func_array('array_multisort', $args); + var_dump($args); + unset($args); + + $array = [3, 2, 1]; + call_user_func('array_multisort', $array); + var_dump($array); + unset($array); +} + +?> +--EXPECT-- +array(1) { + [0]=> + array(3) { + [0]=> + int(3) + [1]=> + int(2) + [2]=> + int(1) + } +} +array(3) { + [0]=> + int(3) + [1]=> + int(2) + [2]=> + int(1) +} +array(1) { + [0]=> + array(3) { + [0]=> + int(3) + [1]=> + int(2) + [2]=> + int(1) + } +} +array(3) { + [0]=> + int(3) + [1]=> + int(2) + [2]=> + int(1) +} diff --git a/Zend/tests/constant_expressions_coalesce.phpt b/Zend/tests/constant_expressions_coalesce.phpt new file mode 100644 index 0000000000..425aba69c4 --- /dev/null +++ b/Zend/tests/constant_expressions_coalesce.phpt @@ -0,0 +1,47 @@ +--TEST-- +Constant expressions with null coalescing operator ?? +--FILE-- +<?php + +const A = [1 => [[]]]; + +const T_1 = null ?? A[1]['undefined']['index'] ?? 1; +const T_2 = null ?? A['undefined']['index'] ?? 2; +const T_3 = null ?? A[1][0][2] ?? 3; +const T_4 = A[1][0][2] ?? 4; +const T_5 = null ?? __LINE__; +const T_6 = __LINE__ ?? "bar"; + +var_dump(T_1); +var_dump(T_2); +var_dump(T_3); +var_dump(T_4); +var_dump(T_5); +var_dump(T_6); + +var_dump((function(){ static $var = null ?? A[1]['undefined']['index'] ?? 1; return $var; })()); +var_dump((function(){ static $var = null ?? A['undefined']['index'] ?? 2; return $var; })()); +var_dump((function(){ static $var = null ?? A[1][0][2] ?? 3; return $var; })()); +var_dump((function(){ static $var = A[1][0][2] ?? 4; return $var; })()); + +var_dump((new class { public $var = null ?? A[1]['undefined']['index'] ?? 1; })->var); +var_dump((new class { public $var = null ?? A['undefined']['index'] ?? 2; })->var); +var_dump((new class { public $var = null ?? A[1][0][2] ?? 3; })->var); +var_dump((new class { public $var = A[1][0][2] ?? 4; })->var); + +?> +--EXPECTF-- +int(1) +int(2) +int(3) +int(4) +int(%d) +int(%d) +int(1) +int(2) +int(3) +int(4) +int(1) +int(2) +int(3) +int(4) diff --git a/Zend/tests/constant_expressions_coalesce_empty_dim.phpt b/Zend/tests/constant_expressions_coalesce_empty_dim.phpt new file mode 100644 index 0000000000..56ee43b789 --- /dev/null +++ b/Zend/tests/constant_expressions_coalesce_empty_dim.phpt @@ -0,0 +1,11 @@ +--TEST-- +Constant expressions with empty dimension fetch on coalesce +--FILE-- +<?php + +const A = [][] ?? 1; + +?> +--EXPECTF-- +Fatal error: Cannot use [] for reading in %s.php on line %d + diff --git a/Zend/tests/constant_expressions_dynamic.phpt b/Zend/tests/constant_expressions_dynamic.phpt index b0ba3a5b19..686dcc1d11 100644 --- a/Zend/tests/constant_expressions_dynamic.phpt +++ b/Zend/tests/constant_expressions_dynamic.phpt @@ -35,10 +35,12 @@ const T_19 = [ false => false, true => true, ]; +eval("const T_20x = 'a';"); +const T_20 = null ?: (T_20x . 'bc'); var_dump( T_1, T_2, T_3, T_4, T_5, T_6, T_7, T_8, T_9, T_10, - T_11, T_12, T_13, T_14, T_15, T_16, T_17, T_18, T_19 + T_11, T_12, T_13, T_14, T_15, T_16, T_17, T_18, T_19, T_20 ); ?> @@ -77,3 +79,4 @@ array(6) { [1]=> bool(true) } +string(3) "abc" diff --git a/Zend/tests/constant_expressions_self_referencing_array.phpt b/Zend/tests/constant_expressions_self_referencing_array.phpt index 63f2b20ef5..c584b5d503 100644 --- a/Zend/tests/constant_expressions_self_referencing_array.phpt +++ b/Zend/tests/constant_expressions_self_referencing_array.phpt @@ -9,7 +9,7 @@ class A { var_dump(A::FOO); ?> --EXPECTF-- -Fatal error: Uncaught Error: Cannot declare self-referencing constant 'self::FOO' in %s:%d +Fatal error: Uncaught Error: Cannot declare self-referencing constant 'self::BAR' in %s:%d Stack trace: #0 {main} thrown in %s on line %d diff --git a/Zend/tests/dynamic_fully_qualified_call.phpt b/Zend/tests/dynamic_fully_qualified_call.phpt new file mode 100644 index 0000000000..cca6fa38b6 --- /dev/null +++ b/Zend/tests/dynamic_fully_qualified_call.phpt @@ -0,0 +1,15 @@ +--TEST-- +Crash when using dynamic call syntax with fully qualified name in a namespace +--FILE-- +<?php + +namespace Foo; +try { + ('\bar')(); +} catch (\Error $e) { + echo $e->getMessage(), "\n"; +} + +?> +--EXPECT-- +Call to undefined function bar() diff --git a/Zend/tests/each_002.phpt b/Zend/tests/each_002.phpt index f47ded4b14..31b749e5fd 100644 --- a/Zend/tests/each_002.phpt +++ b/Zend/tests/each_002.phpt @@ -3,10 +3,12 @@ Testing each() with array and object --FILE-- <?php -$foo = each(new stdClass); +$a = new stdClass; +$foo = each($a); var_dump($foo); -var_dump(each(new stdClass)); +$a = new stdClass; +var_dump(each($a)); $a = array(new stdClass); var_dump(each($a)); diff --git a/Zend/tests/gc_013.phpt b/Zend/tests/gc_013.phpt index 9209ca2b40..0c5424086a 100644 --- a/Zend/tests/gc_013.phpt +++ b/Zend/tests/gc_013.phpt @@ -10,9 +10,9 @@ for ($i = 0; $i < 10001; $i++) { } $a[] = "xxx"; unset($a); -var_dump(gc_collect_cycles()); +var_dump(gc_collect_cycles() > 0); echo "ok\n"; ?> --EXPECT-- -int(2) +bool(true) ok diff --git a/Zend/tests/gc_014.phpt b/Zend/tests/gc_014.phpt index cd5a15e681..4fd8948af5 100644 --- a/Zend/tests/gc_014.phpt +++ b/Zend/tests/gc_014.phpt @@ -12,9 +12,9 @@ for ($i = 0; $i < 10001; $i++) { unset($b); $a->b = "xxx"; unset($a); -var_dump(gc_collect_cycles()); +var_dump(gc_collect_cycles() > 0); echo "ok\n"; ?> --EXPECT-- -int(2) +bool(true) ok diff --git a/Zend/tests/gc_015.phpt b/Zend/tests/gc_015.phpt index df85836ed8..24acddeae1 100644 --- a/Zend/tests/gc_015.phpt +++ b/Zend/tests/gc_015.phpt @@ -12,9 +12,9 @@ $a->b = "xxx"; unset($c); unset($a); unset($b); -var_dump(gc_collect_cycles()); +var_dump(gc_collect_cycles() > 0); echo "ok\n"; ?> --EXPECT-- -int(2) +bool(true) ok diff --git a/Zend/tests/gc_017.phpt b/Zend/tests/gc_017.phpt index 28d51980c9..a1a8c3eaf6 100644 --- a/Zend/tests/gc_017.phpt +++ b/Zend/tests/gc_017.phpt @@ -31,12 +31,12 @@ $a->insert($c); unset($a); unset($b); unset($c); -var_dump(gc_collect_cycles()); +var_dump(gc_collect_cycles() >= 7); echo "ok\n" ?> --EXPECTF-- string(1) "%s" string(1) "%s" string(1) "%s" -int(10) +bool(true) ok diff --git a/Zend/tests/generators/gc_with_yield_from.phpt b/Zend/tests/generators/gc_with_yield_from.phpt new file mode 100644 index 0000000000..8c05561990 --- /dev/null +++ b/Zend/tests/generators/gc_with_yield_from.phpt @@ -0,0 +1,45 @@ +--TEST-- +Verify yield from on generators being properly cycle collected +--FILE-- +<?php + +function root() { + global $gens; // create cyclic reference to root + try { + yield 1; + } finally { + var_dump($gens); + } +} + +function gen($x) { + global $gens; + yield from $gens[] = $x ? gen(--$x) : root(); +} + +$gen = $gens[] = gen(2); +var_dump($gen->current()); +unset($gen, $gens); +print "collect\n"; +gc_collect_cycles(); +print "end\n"; + +?> +--EXPECT-- +int(1) +collect +array(4) { + [0]=> + object(Generator)#1 (0) { + } + [1]=> + object(Generator)#2 (0) { + } + [2]=> + object(Generator)#3 (0) { + } + [3]=> + object(Generator)#4 (0) { + } +} +end diff --git a/Zend/tests/invalid_parent_const_ref_leak.phpt b/Zend/tests/invalid_parent_const_ref_leak.phpt new file mode 100644 index 0000000000..33e2548f31 --- /dev/null +++ b/Zend/tests/invalid_parent_const_ref_leak.phpt @@ -0,0 +1,18 @@ +--TEST-- +Leak when using an invalid parent:: reference in a constant definition +--FILE-- +<?php + +class A { + const B = parent::C; +} + +try { + A::B; +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +?> +--EXPECT-- +Cannot access parent:: when current class scope has no parent diff --git a/Zend/tests/list_keyed_conversions.phpt b/Zend/tests/list_keyed_conversions.phpt index e2cf91a27d..bf0349b327 100644 --- a/Zend/tests/list_keyed_conversions.phpt +++ b/Zend/tests/list_keyed_conversions.phpt @@ -30,3 +30,5 @@ int(0) int(1) Notice: Resource ID#%d used as offset, casting to integer (%d) in %s on line %d + +Notice: Undefined offset: 1 in %s on line %d diff --git a/Zend/tests/method_argument_binding.phpt b/Zend/tests/method_argument_binding.phpt new file mode 100644 index 0000000000..731cc4fb32 --- /dev/null +++ b/Zend/tests/method_argument_binding.phpt @@ -0,0 +1,47 @@ +--TEST-- +Edge cases in compile-time method argument binding +--FILE-- +<?php + +class A { + private function method($x) {} +} + +class B extends A { + public function test() { + $x = 1; + $this->method($x); + var_dump($x); + } +} + +class C extends B { + public function method(&$x) { + ++$x; + } +} + +(new C)->test(); + +class D { + private final function method(&$x) { + ++$x; + } +} + +class E extends D { + public function __call($name, $args) { } + + public function test() { + $this->method($x); + } +} + +(new E)->test(); + +?> +--EXPECTF-- +Warning: Declaration of C::method(&$x) should be compatible with A::method($x) in %s on line %d +int(2) + +Notice: Undefined variable: x in %s on line %d diff --git a/Zend/tests/modify_isref_value_return.phpt b/Zend/tests/modify_isref_value_return.phpt new file mode 100644 index 0000000000..1b3122711e --- /dev/null +++ b/Zend/tests/modify_isref_value_return.phpt @@ -0,0 +1,25 @@ +--TEST-- +Indirect modification of isref by-value return value not possible +--FILE-- +<?php + +class A { + public $b; +} + +$arr = []; + +$a = new A; +$a->b =& $arr; + +(new ReflectionProperty('A', 'b'))->getValue($a)[] = 42; + +var_dump($a); + +?> +--EXPECT-- +object(A)#1 (1) { + ["b"]=> + &array(0) { + } +} diff --git a/Zend/tests/php_errormsg_misoptimization.phpt b/Zend/tests/php_errormsg_misoptimization.phpt new file mode 100644 index 0000000000..c121c1021a --- /dev/null +++ b/Zend/tests/php_errormsg_misoptimization.phpt @@ -0,0 +1,20 @@ +--TEST-- +The variable $php_errormsg shouldn't be optimized as it may be unpredictably modified +--INI-- +track_errors=1 +--FILE-- +<?php + +function test() { + $php_errormsg = 1; + echo $undef; + var_dump($php_errormsg + 1); +} +test(); + +?> +--EXPECTF-- +Notice: Undefined variable: undef in %s on line %d + +Warning: A non-numeric value encountered in %s on line %d +int(1) diff --git a/Zend/tests/qm_assign_ref_unwrap_leak.phpt b/Zend/tests/qm_assign_ref_unwrap_leak.phpt new file mode 100644 index 0000000000..137aff5212 --- /dev/null +++ b/Zend/tests/qm_assign_ref_unwrap_leak.phpt @@ -0,0 +1,20 @@ +--TEST-- +Leak in QM_ASSIGN when unwrapping references (rc=1) +--FILE-- +<?php + +function &ref() { + $str = "str"; + $str .= "str"; + return $str; +} + +var_dump(true ? ref() : ref()); +var_dump(ref() ?: ref()); +var_dump(ref() ?? ref()); + +?> +--EXPECT-- +string(6) "strstr" +string(6) "strstr" +string(6) "strstr" diff --git a/Zend/tests/try/exceptions.inc b/Zend/tests/try/exceptions.inc new file mode 100644 index 0000000000..68cb1c62f7 --- /dev/null +++ b/Zend/tests/try/exceptions.inc @@ -0,0 +1,6 @@ +<?php + +class Exception1 extends Exception {} +class Exception2 extends Exception {} +class Exception3 extends Exception {} +class Exception4 extends Exception {} diff --git a/Zend/tests/try/try_multicatch_001.phpt b/Zend/tests/try/try_multicatch_001.phpt new file mode 100644 index 0000000000..0dffd32c72 --- /dev/null +++ b/Zend/tests/try/try_multicatch_001.phpt @@ -0,0 +1,19 @@ +--TEST-- +Parsing test +--FILE-- +<?php + +require_once __DIR__ . '/exceptions.inc'; + +try { + echo 'TRY' . PHP_EOL; +} catch(Exception1 | Exception2 $e) { + echo 'Exception'; +} finally { + echo 'FINALLY' . PHP_EOL; +} + +?> +--EXPECT-- +TRY +FINALLY diff --git a/Zend/tests/try/try_multicatch_002.phpt b/Zend/tests/try/try_multicatch_002.phpt new file mode 100644 index 0000000000..0e70fec7eb --- /dev/null +++ b/Zend/tests/try/try_multicatch_002.phpt @@ -0,0 +1,21 @@ +--TEST-- +Catch first exception in the multicatch +--FILE-- +<?php + +require_once __DIR__ . '/exceptions.inc'; + +try { + echo 'TRY' . PHP_EOL; + throw new Exception1; +} catch(Exception1 | Exception2 | Exception3 $e) { + echo get_class($e) . PHP_EOL; +} finally { + echo 'FINALLY' . PHP_EOL; +} + +?> +--EXPECT-- +TRY +Exception1 +FINALLY diff --git a/Zend/tests/try/try_multicatch_003.phpt b/Zend/tests/try/try_multicatch_003.phpt new file mode 100644 index 0000000000..6aed1a2b09 --- /dev/null +++ b/Zend/tests/try/try_multicatch_003.phpt @@ -0,0 +1,21 @@ +--TEST-- +Catch second exception in the multicatch +--FILE-- +<?php + +require_once __DIR__ . '/exceptions.inc'; + +try { + echo 'TRY' . PHP_EOL; + throw new Exception2; +} catch(Exception1 | Exception2 | Exception3 $e) { + echo get_class($e) . PHP_EOL; +} finally { + echo 'FINALLY' . PHP_EOL; +} + +?> +--EXPECT-- +TRY +Exception2 +FINALLY diff --git a/Zend/tests/try/try_multicatch_004.phpt b/Zend/tests/try/try_multicatch_004.phpt new file mode 100644 index 0000000000..d8b245a767 --- /dev/null +++ b/Zend/tests/try/try_multicatch_004.phpt @@ -0,0 +1,21 @@ +--TEST-- +Catch last exception in the multicatch +--FILE-- +<?php + +require_once __DIR__ . '/exceptions.inc'; + +try { + echo 'TRY' . PHP_EOL; + throw new Exception3; +} catch(Exception1 | Exception2 | Exception3 $e) { + echo get_class($e) . PHP_EOL; +} finally { + echo 'FINALLY' . PHP_EOL; +} + +?> +--EXPECT-- +TRY +Exception3 +FINALLY diff --git a/Zend/tests/try/try_multicatch_005.phpt b/Zend/tests/try/try_multicatch_005.phpt new file mode 100644 index 0000000000..cc3fc890fa --- /dev/null +++ b/Zend/tests/try/try_multicatch_005.phpt @@ -0,0 +1,25 @@ +--TEST-- +Catch exception in the nested multicatch +--FILE-- +<?php + +require_once __DIR__ . '/exceptions.inc'; + +try { + try { + echo 'TRY' . PHP_EOL; + throw new Exception3; + } catch (Exception1 | Exception3 $e) { + echo get_class($e) . PHP_EOL; + } +} catch(Exception2 | Exception3 $e) { + echo 'Should never be executed'; +} finally { + echo 'FINALLY' . PHP_EOL; +} + +?> +--EXPECT-- +TRY +Exception3 +FINALLY diff --git a/Zend/tests/try/try_multicatch_006.phpt b/Zend/tests/try/try_multicatch_006.phpt new file mode 100644 index 0000000000..e4505f1b24 --- /dev/null +++ b/Zend/tests/try/try_multicatch_006.phpt @@ -0,0 +1,22 @@ +--TEST-- +Catch first exception in the second multicatch +--FILE-- +<?php +require_once __DIR__ . '/exceptions.inc'; + +try { + echo 'TRY' . PHP_EOL; + throw new Exception3; +} catch(Exception1 | Exception2 $e) { + echo get_class($e) . PHP_EOL; +} catch(Exception3 | Exception4 $e) { + echo get_class($e) . PHP_EOL; +} finally { + echo 'FINALLY' . PHP_EOL; +} +?> +--EXPECT-- +TRY +Exception3 +FINALLY + diff --git a/Zend/tests/try/try_multicatch_007.phpt b/Zend/tests/try/try_multicatch_007.phpt new file mode 100644 index 0000000000..aa073b0592 --- /dev/null +++ b/Zend/tests/try/try_multicatch_007.phpt @@ -0,0 +1,22 @@ +--TEST-- +Catch second exception in the second multicatch +--FILE-- +<?php +require_once __DIR__ . '/exceptions.inc'; + +try { + echo 'TRY' . PHP_EOL; + throw new Exception4; +} catch(Exception1 | Exception2 $e) { + echo get_class($e) . PHP_EOL; +} catch(Exception3 | Exception4 $e) { + echo get_class($e) . PHP_EOL; +} finally { + echo 'FINALLY' . PHP_EOL; +} +?> +--EXPECT-- +TRY +Exception4 +FINALLY + diff --git a/Zend/zend_API.c b/Zend/zend_API.c index 18e6e0f4f4..f646883435 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -1063,11 +1063,11 @@ ZEND_API int _array_init(zval *arg, uint32_t size ZEND_FILE_LINE_DC) /* {{{ */ ZEND_API void zend_merge_properties(zval *obj, HashTable *properties) /* {{{ */ { const zend_object_handlers *obj_ht = Z_OBJ_HT_P(obj); - zend_class_entry *old_scope = EG(scope); + zend_class_entry *old_scope = EG(fake_scope); zend_string *key; zval *value; - EG(scope) = Z_OBJCE_P(obj); + EG(fake_scope) = Z_OBJCE_P(obj); ZEND_HASH_FOREACH_STR_KEY_VAL(properties, key, value) { if (key) { zval member; @@ -1076,7 +1076,7 @@ ZEND_API void zend_merge_properties(zval *obj, HashTable *properties) /* {{{ */ obj_ht->write_property(obj, &member, value, NULL); } } ZEND_HASH_FOREACH_END(); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; } /* }}} */ @@ -1119,18 +1119,15 @@ ZEND_API int zend_update_class_constants(zend_class_entry *class_type) /* {{{ */ } } } else { - zend_class_entry **scope = EG(current_execute_data) ? &EG(scope) : &CG(active_class_entry); - zend_class_entry *old_scope = *scope; zend_class_entry *ce; zend_class_constant *c; zval *val; zend_property_info *prop_info; - *scope = class_type; ZEND_HASH_FOREACH_PTR(&class_type->constants_table, c) { val = &c->value; if (Z_CONSTANT_P(val)) { - if (UNEXPECTED(zval_update_constant_ex(val, 1, class_type) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(val, class_type) != SUCCESS)) { return FAILURE; } } @@ -1147,8 +1144,7 @@ ZEND_API int zend_update_class_constants(zend_class_entry *class_type) /* {{{ */ } ZVAL_DEREF(val); if (Z_CONSTANT_P(val)) { - *scope = ce; - if (UNEXPECTED(zval_update_constant_ex(val, 1, NULL) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(val, ce) != SUCCESS)) { return FAILURE; } } @@ -1156,8 +1152,6 @@ ZEND_API int zend_update_class_constants(zend_class_entry *class_type) /* {{{ */ } ZEND_HASH_FOREACH_END(); ce = ce->parent; } - - *scope = old_scope; } } return SUCCESS; @@ -1221,15 +1215,15 @@ ZEND_API void object_properties_load(zend_object *object, HashTable *properties) size_t prop_name_len; if (zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_name_len) == SUCCESS) { zend_string *pname = zend_string_init(prop_name, prop_name_len, 0); - zend_class_entry *prev_scope = EG(scope); + zend_class_entry *prev_scope = EG(fake_scope); if (class_name && class_name[0] != '*') { zend_string *cname = zend_string_init(class_name, strlen(class_name), 0); - EG(scope) = zend_lookup_class(cname); + EG(fake_scope) = zend_lookup_class(cname); zend_string_release(cname); } property_info = zend_get_property_info(object->ce, pname, 1); zend_string_release(pname); - EG(scope) = prev_scope; + EG(fake_scope) = prev_scope; } else { property_info = ZEND_WRONG_PROPERTY_INFO; } @@ -2819,7 +2813,7 @@ ZEND_API int zend_disable_class(char *class_name, size_t class_name_length) /* { } /* }}} */ -static int zend_is_callable_check_class(zend_string *name, zend_fcall_info_cache *fcc, int *strict_class, char **error) /* {{{ */ +static int zend_is_callable_check_class(zend_string *name, zend_class_entry *scope, zend_fcall_info_cache *fcc, int *strict_class, char **error) /* {{{ */ { int ret = 0; zend_class_entry *ce; @@ -2832,24 +2826,24 @@ static int zend_is_callable_check_class(zend_string *name, zend_fcall_info_cache *strict_class = 0; if (zend_string_equals_literal(lcname, "self")) { - if (!EG(scope)) { + if (!scope) { if (error) *error = estrdup("cannot access self:: when no class scope is active"); } else { fcc->called_scope = zend_get_called_scope(EG(current_execute_data)); - fcc->calling_scope = EG(scope); + fcc->calling_scope = scope; if (!fcc->object) { fcc->object = zend_get_this_object(EG(current_execute_data)); } ret = 1; } } else if (zend_string_equals_literal(lcname, "parent")) { - if (!EG(scope)) { + if (!scope) { if (error) *error = estrdup("cannot access parent:: when no class scope is active"); - } else if (!EG(scope)->parent) { + } else if (!scope->parent) { if (error) *error = estrdup("cannot access parent:: when current class scope has no parent"); } else { fcc->called_scope = zend_get_called_scope(EG(current_execute_data)); - fcc->calling_scope = EG(scope)->parent; + fcc->calling_scope = scope->parent; if (!fcc->object) { fcc->object = zend_get_this_object(EG(current_execute_data)); } @@ -2911,9 +2905,9 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca zend_string *lmname; const char *colon; size_t clen, mlen; - zend_class_entry *last_scope; HashTable *ftable; int call_via_handler = 0; + zend_class_entry *scope; ALLOCA_FLAG(use_heap) if (error) { @@ -2974,19 +2968,18 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca /* This is a compound name. * Try to fetch class and then find static method. */ - last_scope = EG(scope); if (ce_org) { - EG(scope) = ce_org; + scope = ce_org; + } else { + scope = zend_get_executed_scope(); } cname = zend_string_init(Z_STRVAL_P(callable), clen, 0); - if (!zend_is_callable_check_class(cname, fcc, &strict_class, error)) { + if (!zend_is_callable_check_class(cname, scope, fcc, &strict_class, error)) { zend_string_release(cname); - EG(scope) = last_scope; return 0; } zend_string_release(cname); - EG(scope) = last_scope; ftable = &fcc->calling_scope->function_table; if (ce_org && !instanceof_function(ce_org, fcc->calling_scope)) { @@ -3020,14 +3013,17 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca } else if ((fcc->function_handler = zend_hash_find_ptr(ftable, lmname)) != NULL) { retval = 1; if ((fcc->function_handler->op_array.fn_flags & ZEND_ACC_CHANGED) && - !strict_class && EG(scope) && - instanceof_function(fcc->function_handler->common.scope, EG(scope))) { - zend_function *priv_fbc; - - if ((priv_fbc = zend_hash_find_ptr(&EG(scope)->function_table, lmname)) != NULL - && priv_fbc->common.fn_flags & ZEND_ACC_PRIVATE - && priv_fbc->common.scope == EG(scope)) { - fcc->function_handler = priv_fbc; + !strict_class) { + scope = zend_get_executed_scope(); + if (scope && + instanceof_function(fcc->function_handler->common.scope, scope)) { + zend_function *priv_fbc; + + if ((priv_fbc = zend_hash_find_ptr(&scope->function_table, lmname)) != NULL + && priv_fbc->common.fn_flags & ZEND_ACC_PRIVATE + && priv_fbc->common.scope == scope) { + fcc->function_handler = priv_fbc; + } } } if ((check_flags & IS_CALLABLE_CHECK_NO_ACCESS) == 0 && @@ -3035,13 +3031,15 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca ((fcc->object && fcc->calling_scope->__call) || (!fcc->object && fcc->calling_scope->__callstatic)))) { if (fcc->function_handler->op_array.fn_flags & ZEND_ACC_PRIVATE) { - if (!zend_check_private(fcc->function_handler, fcc->object ? fcc->object->ce : EG(scope), lmname)) { + scope = zend_get_executed_scope(); + if (!zend_check_private(fcc->function_handler, fcc->object ? fcc->object->ce : scope, lmname)) { retval = 0; fcc->function_handler = NULL; goto get_function_via_handler; } } else if (fcc->function_handler->common.fn_flags & ZEND_ACC_PROTECTED) { - if (!zend_check_protected(fcc->function_handler->common.scope, EG(scope))) { + scope = zend_get_executed_scope(); + if (!zend_check_protected(fcc->function_handler->common.scope, scope)) { retval = 0; fcc->function_handler = NULL; goto get_function_via_handler; @@ -3132,7 +3130,8 @@ get_function_via_handler: } if (retval && (check_flags & IS_CALLABLE_CHECK_NO_ACCESS) == 0) { if (fcc->function_handler->op_array.fn_flags & ZEND_ACC_PRIVATE) { - if (!zend_check_private(fcc->function_handler, fcc->object ? fcc->object->ce : EG(scope), lmname)) { + scope = zend_get_executed_scope(); + if (!zend_check_private(fcc->function_handler, fcc->object ? fcc->object->ce : scope, lmname)) { if (error) { if (*error) { efree(*error); @@ -3142,7 +3141,8 @@ get_function_via_handler: retval = 0; } } else if ((fcc->function_handler->common.fn_flags & ZEND_ACC_PROTECTED)) { - if (!zend_check_protected(fcc->function_handler->common.scope, EG(scope))) { + scope = zend_get_executed_scope(); + if (!zend_check_protected(fcc->function_handler->common.scope, scope)) { if (error) { if (*error) { efree(*error); @@ -3279,7 +3279,7 @@ again: return 1; } - if (!zend_is_callable_check_class(Z_STR_P(obj), fcc, &strict_class, error)) { + if (!zend_is_callable_check_class(Z_STR_P(obj), zend_get_executed_scope(), fcc, &strict_class, error)) { return 0; } @@ -3353,6 +3353,7 @@ again: memcpy(ZSTR_VAL(*callable_name), ZSTR_VAL(ce->name), ZSTR_LEN(ce->name)); memcpy(ZSTR_VAL(*callable_name) + ZSTR_LEN(ce->name), "::__invoke", sizeof("::__invoke")); } + fcc->initialized = 1; return 1; } if (callable_name) { @@ -3412,7 +3413,6 @@ ZEND_API int zend_fcall_info_init(zval *callable, uint check_flags, zend_fcall_i } fci->size = sizeof(*fci); - fci->function_table = fcc->calling_scope ? &fcc->calling_scope->function_table : EG(function_table); fci->object = fcc->object; ZVAL_COPY_VALUE(&fci->function_name, callable); fci->retval = NULL; @@ -3839,9 +3839,9 @@ ZEND_API int zend_declare_class_constant_string(zend_class_entry *ce, const char ZEND_API void zend_update_property_ex(zend_class_entry *scope, zval *object, zend_string *name, zval *value) /* {{{ */ { zval property; - zend_class_entry *old_scope = EG(scope); + zend_class_entry *old_scope = EG(fake_scope); - EG(scope) = scope; + EG(fake_scope) = scope; if (!Z_OBJ_HT_P(object)->write_property) { zend_error_noreturn(E_CORE_ERROR, "Property %s of class %s cannot be updated", name, ZSTR_VAL(Z_OBJCE_P(object)->name)); @@ -3849,16 +3849,16 @@ ZEND_API void zend_update_property_ex(zend_class_entry *scope, zval *object, zen ZVAL_STR(&property, name); Z_OBJ_HT_P(object)->write_property(object, &property, value, NULL); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; } /* }}} */ ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zval *value) /* {{{ */ { zval property; - zend_class_entry *old_scope = EG(scope); + zend_class_entry *old_scope = EG(fake_scope); - EG(scope) = scope; + EG(fake_scope) = scope; if (!Z_OBJ_HT_P(object)->write_property) { zend_error_noreturn(E_CORE_ERROR, "Property %s of class %s cannot be updated", name, ZSTR_VAL(Z_OBJCE_P(object)->name)); @@ -3867,7 +3867,7 @@ ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const Z_OBJ_HT_P(object)->write_property(object, &property, value, NULL); zval_ptr_dtor(&property); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; } /* }}} */ @@ -3939,12 +3939,12 @@ ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *name, size_t name_length, zval *value) /* {{{ */ { zval *property; - zend_class_entry *old_scope = EG(scope); + zend_class_entry *old_scope = EG(fake_scope); zend_string *key = zend_string_init(name, name_length, 0); - EG(scope) = scope; + EG(fake_scope) = scope; property = zend_std_get_static_property(scope, key, 0); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; zend_string_free(key); if (!property) { return FAILURE; @@ -4034,9 +4034,9 @@ ZEND_API int zend_update_static_property_stringl(zend_class_entry *scope, const ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_bool silent, zval *rv) /* {{{ */ { zval property, *value; - zend_class_entry *old_scope = EG(scope); + zend_class_entry *old_scope = EG(fake_scope); - EG(scope) = scope; + EG(fake_scope) = scope; if (!Z_OBJ_HT_P(object)->read_property) { zend_error_noreturn(E_CORE_ERROR, "Property %s of class %s cannot be read", name, ZSTR_VAL(Z_OBJCE_P(object)->name)); @@ -4046,7 +4046,7 @@ ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const c value = Z_OBJ_HT_P(object)->read_property(object, &property, silent?BP_VAR_IS:BP_VAR_R, NULL, rv); zval_ptr_dtor(&property); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; return value; } /* }}} */ @@ -4054,12 +4054,12 @@ ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const c ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *name, size_t name_length, zend_bool silent) /* {{{ */ { zval *property; - zend_class_entry *old_scope = EG(scope); + zend_class_entry *old_scope = EG(fake_scope); zend_string *key = zend_string_init(name, name_length, 0); - EG(scope) = scope; + EG(fake_scope) = scope; property = zend_std_get_static_property(scope, key, silent); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; zend_string_free(key); return property; diff --git a/Zend/zend_API.h b/Zend/zend_API.h index 07b48365f3..cc54a90867 100644 --- a/Zend/zend_API.h +++ b/Zend/zend_API.h @@ -43,7 +43,6 @@ typedef struct _zend_function_entry { typedef struct _zend_fcall_info { size_t size; - HashTable *function_table; zval function_name; zval *retval; zval *params; @@ -468,11 +467,12 @@ ZEND_API int add_property_zval_ex(zval *arg, const char *key, size_t key_len, zv #define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key), __value) -ZEND_API int call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[]); -ZEND_API int _call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], int no_separation); +ZEND_API int _call_user_function_ex(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], int no_separation); +#define call_user_function(function_table, object, function_name, retval_ptr, param_count, params) \ + _call_user_function_ex(object, function_name, retval_ptr, param_count, params, 1) #define call_user_function_ex(function_table, object, function_name, retval_ptr, param_count, params, no_separation, symbol_table) \ - _call_user_function_ex(function_table, object, function_name, retval_ptr, param_count, params, no_separation) + _call_user_function_ex(object, function_name, retval_ptr, param_count, params, no_separation) ZEND_API extern const zend_fcall_info empty_fcall_info; ZEND_API extern const zend_fcall_info_cache empty_fcall_info_cache; diff --git a/Zend/zend_alloc.c b/Zend/zend_alloc.c index 1876559317..e7a8e0d2a5 100644 --- a/Zend/zend_alloc.c +++ b/Zend/zend_alloc.c @@ -1862,7 +1862,7 @@ static zend_mm_heap *zend_mm_init(void) heap->peak = 0; #endif #if ZEND_MM_LIMIT - heap->limit = (Z_L(-1) >> Z_L(1)); + heap->limit = ((size_t)Z_L(-1) >> (size_t)Z_L(1)); heap->overflow = 0; #endif #if ZEND_MM_CUSTOM diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index cfcd636269..2636d2d561 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -256,23 +256,23 @@ ZEND_API int zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *sc case ZEND_AST_ZVAL: { zval *zv = zend_ast_get_zval(ast); - if (scope) { - /* class constants may be updated in-place */ - if (Z_OPT_CONSTANT_P(zv)) { - if (UNEXPECTED(zval_update_constant_ex(zv, 1, scope) != SUCCESS)) { + + if (Z_OPT_CONSTANT_P(zv)) { + if (!(Z_TYPE_FLAGS_P(zv) & IS_TYPE_IMMUTABLE)) { + if (UNEXPECTED(zval_update_constant_ex(zv, scope) != SUCCESS)) { ret = FAILURE; break; } - } - ZVAL_DUP(result, zv); - } else { - ZVAL_DUP(result, zv); - if (Z_OPT_CONSTANT_P(result)) { - if (UNEXPECTED(zval_update_constant_ex(result, 1, scope) != SUCCESS)) { + ZVAL_COPY(result, zv); + } else { + ZVAL_COPY_VALUE(result, zv); + if (UNEXPECTED(zval_update_constant_ex(result, scope) != SUCCESS)) { ret = FAILURE; break; } } + } else { + ZVAL_COPY(result, zv); } break; } @@ -337,6 +337,22 @@ ZEND_API int zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *sc zval_dtor(&op1); } break; + case ZEND_AST_COALESCE: + if (UNEXPECTED(zend_ast_evaluate(&op1, ast->child[0], scope) != SUCCESS)) { + ret = FAILURE; + break; + } + if (Z_TYPE(op1) > IS_NULL) { + *result = op1; + } else { + if (UNEXPECTED(zend_ast_evaluate(result, ast->child[1], scope) != SUCCESS)) { + zval_dtor(&op1); + ret = FAILURE; + break; + } + zval_dtor(&op1); + } + break; case ZEND_AST_UNARY_PLUS: if (UNEXPECTED(zend_ast_evaluate(&op2, ast->child[0], scope) != SUCCESS)) { ret = FAILURE; @@ -385,6 +401,10 @@ ZEND_API int zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *sc } break; case ZEND_AST_DIM: + if (ast->child[1] == NULL) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading"); + } + if (UNEXPECTED(zend_ast_evaluate(&op1, ast->child[0], scope) != SUCCESS)) { ret = FAILURE; } else if (UNEXPECTED(zend_ast_evaluate(&op2, ast->child[1], scope) != SUCCESS)) { @@ -393,7 +413,12 @@ ZEND_API int zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *sc } else { zval tmp; - zend_fetch_dimension_by_zval(&tmp, &op1, &op2); + if (ast->attr == ZEND_DIM_IS) { + zend_fetch_dimension_by_zval_is(&tmp, &op1, &op2, IS_CONST); + } else { + zend_fetch_dimension_by_zval(&tmp, &op1, &op2); + } + if (UNEXPECTED(Z_ISREF(tmp))) { ZVAL_DUP(result, Z_REFVAL(tmp)); } else { @@ -751,19 +776,22 @@ static void zend_ast_export_encaps_list(smart_str *str, char quote, zend_ast_lis } } -static void zend_ast_export_name_list(smart_str *str, zend_ast_list *list, int indent) +static void zend_ast_export_name_list_ex(smart_str *str, zend_ast_list *list, int indent, const char *separator) { uint32_t i = 0; while (i < list->children) { if (i != 0) { - smart_str_appends(str, ", "); + smart_str_appends(str, separator); } zend_ast_export_name(str, list->child[i], 0, indent); i++; } } +#define zend_ast_export_name_list(s, l, i) zend_ast_export_name_list_ex(s, l, i, ", ") +#define zend_ast_export_catch_name_list(s, l, i) zend_ast_export_name_list_ex(s, l, i, "|") + static void zend_ast_export_var_list(smart_str *str, zend_ast_list *list, int indent) { uint32_t i = 0; @@ -1559,7 +1587,7 @@ simple_list: break; case ZEND_AST_CATCH: smart_str_appends(str, "} catch ("); - zend_ast_export_ns_name(str, ast->child[0], 0, indent); + zend_ast_export_catch_name_list(str, zend_ast_get_list(ast->child[0]), indent); smart_str_appends(str, " $"); zend_ast_export_var(str, ast->child[1], 0, indent); smart_str_appends(str, ") {\n"); diff --git a/Zend/zend_bitset.h b/Zend/zend_bitset.h index e3c2ec748d..fb19b54329 100644 --- a/Zend/zend_bitset.h +++ b/Zend/zend_bitset.h @@ -174,6 +174,33 @@ static inline int zend_bitset_last(zend_bitset set, uint32_t len) return -1; /* empty set */ } +#define ZEND_BITSET_FOREACH(set, len, bit) do { \ + zend_bitset _set = (set); \ + uint32_t _i, _len = (len); \ + for (_i = 0; _i < len; _i++) { \ + zend_ulong _x = _set[_i]; \ + if (_x) { \ + (bit) = ZEND_BITSET_ELM_SIZE * 8 * _i; \ + for (; _x != 0; _x >>= Z_UL(1), (bit)++) { \ + if (!(_x & Z_UL(1))) continue; + +#define ZEND_BITSET_REVERSE_FOREACH(set, len, bit) do { \ + zend_bitset _set = (set); \ + uint32_t _i = (len); \ + zend_ulong _test = Z_UL(1) << (ZEND_BITSET_ELM_SIZE * 8 - 1); \ + while (_i-- > 0) { \ + zend_ulong _x = _set[_i]; \ + if (_x) { \ + (bit) = ZEND_BITSET_ELM_SIZE * 8 * (_i + 1) - 1; \ + for (; _x != 0; _x <<= Z_UL(1), (bit)--) { \ + if (!(_x & _test)) continue; \ + +#define ZEND_BITSET_FOREACH_END() \ + } \ + } \ + } \ +} while (0) + #endif /* _ZEND_BITSET_H_ */ /* diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 0cbafc7818..e5f77d8960 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -526,13 +526,13 @@ ZEND_FUNCTION(func_get_arg) arg_count = ZEND_CALL_NUM_ARGS(ex); - if (requested_offset >= arg_count) { + if ((zend_ulong)requested_offset >= arg_count) { zend_error(E_WARNING, "func_get_arg(): Argument " ZEND_LONG_FMT " not passed to function", requested_offset); RETURN_FALSE; } first_extra_arg = ex->func->op_array.num_args; - if (requested_offset >= first_extra_arg && (ZEND_CALL_NUM_ARGS(ex) > first_extra_arg)) { + if ((zend_ulong)requested_offset >= first_extra_arg && (ZEND_CALL_NUM_ARGS(ex) > first_extra_arg)) { arg = ZEND_CALL_VAR_NUM(ex, ex->func->op_array.last_var + ex->func->op_array.T) + (requested_offset - first_extra_arg); } else { arg = ZEND_CALL_ARG(ex, requested_offset + 1); @@ -755,7 +755,7 @@ ZEND_FUNCTION(each) Return the current error_reporting level, and if an argument was passed - change to the new level */ ZEND_FUNCTION(error_reporting) { - zval *err; + zval *err = NULL; int old_error_reporting; #ifndef FAST_ZPP @@ -982,7 +982,7 @@ ZEND_FUNCTION(defined) ZEND_PARSE_PARAMETERS_END(); #endif - if (zend_get_constant_ex(name, NULL, ZEND_FETCH_CLASS_SILENT)) { + if (zend_get_constant_ex(name, zend_get_executed_scope(), ZEND_FETCH_CLASS_SILENT)) { RETURN_TRUE; } else { RETURN_FALSE; @@ -1001,8 +1001,10 @@ ZEND_FUNCTION(get_class) } if (!obj) { - if (EG(scope)) { - RETURN_STR_COPY(EG(scope)->name); + zend_class_entry *scope = zend_get_executed_scope(); + + if (scope) { + RETURN_STR_COPY(scope->name); } else { zend_error(E_WARNING, "get_class() called without object from outside a class"); RETURN_FALSE; @@ -1026,8 +1028,11 @@ ZEND_FUNCTION(get_called_class) called_scope = zend_get_called_scope(execute_data); if (called_scope) { RETURN_STR_COPY(called_scope->name); - } else if (!EG(scope)) { - zend_error(E_WARNING, "get_called_class() called from outside a class"); + } else { + zend_class_entry *scope = zend_get_executed_scope(); + if (!scope) { + zend_error(E_WARNING, "get_called_class() called from outside a class"); + } } RETURN_FALSE; } @@ -1045,7 +1050,7 @@ ZEND_FUNCTION(get_parent_class) } if (!ZEND_NUM_ARGS()) { - ce = EG(scope); + ce = zend_get_executed_scope(); if (ce && ce->parent) { RETURN_STR_COPY(ce->parent->name); } else { @@ -1142,7 +1147,7 @@ ZEND_FUNCTION(is_a) /* }}} */ /* {{{ add_class_vars */ -static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value) +static void add_class_vars(zend_class_entry *scope, zend_class_entry *ce, int statics, zval *return_value) { zend_property_info *prop_info; zval *prop, prop_copy; @@ -1150,12 +1155,12 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->properties_info, key, prop_info) { if (((prop_info->flags & ZEND_ACC_SHADOW) && - prop_info->ce != EG(scope)) || + prop_info->ce != scope) || ((prop_info->flags & ZEND_ACC_PROTECTED) && - !zend_check_protected(prop_info->ce, EG(scope))) || + !zend_check_protected(prop_info->ce, scope)) || ((prop_info->flags & ZEND_ACC_PRIVATE) && - ce != EG(scope) && - prop_info->ce != EG(scope))) { + ce != scope && + prop_info->ce != scope)) { continue; } prop = NULL; @@ -1180,7 +1185,7 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value /* this is necessary to make it able to work with default array * properties, returned to user */ if (Z_OPT_CONSTANT_P(prop)) { - if (UNEXPECTED(zval_update_constant_ex(prop, 0, NULL) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(prop, NULL) != SUCCESS)) { return; } } @@ -1195,7 +1200,7 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value ZEND_FUNCTION(get_class_vars) { zend_string *class_name; - zend_class_entry *ce; + zend_class_entry *ce, *scope; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &class_name) == FAILURE) { return; @@ -1211,8 +1216,9 @@ ZEND_FUNCTION(get_class_vars) return; } } - add_class_vars(ce, 0, return_value); - add_class_vars(ce, 1, return_value); + scope = zend_get_executed_scope(); + add_class_vars(scope, ce, 0, return_value); + add_class_vars(scope, ce, 1, return_value); } } /* }}} */ @@ -1310,6 +1316,7 @@ ZEND_FUNCTION(get_class_methods) zval *klass; zval method_name; zend_class_entry *ce = NULL; + zend_class_entry *scope; zend_function *mptr; zend_string *key; @@ -1328,15 +1335,16 @@ ZEND_FUNCTION(get_class_methods) } array_init(return_value); + scope = zend_get_executed_scope(); ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->function_table, key, mptr) { if ((mptr->common.fn_flags & ZEND_ACC_PUBLIC) - || (EG(scope) && + || (scope && (((mptr->common.fn_flags & ZEND_ACC_PROTECTED) && - zend_check_protected(mptr->common.scope, EG(scope))) + zend_check_protected(mptr->common.scope, scope)) || ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) && - EG(scope) == mptr->common.scope)))) { + scope == mptr->common.scope)))) { size_t len = ZSTR_LEN(mptr->common.function_name); /* Do not display old-style inherited constructors */ diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c index fd0738f32f..989ef769c8 100644 --- a/Zend/zend_closures.c +++ b/Zend/zend_closures.c @@ -52,17 +52,11 @@ static zend_object_handlers closure_handlers; ZEND_METHOD(Closure, __invoke) /* {{{ */ { zend_function *func = EX(func); - zval *arguments; + zval *arguments = ZEND_CALL_ARG(execute_data, 1); - arguments = emalloc(sizeof(zval) * ZEND_NUM_ARGS()); - if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), arguments) == FAILURE) { - efree(arguments); - zend_throw_error(NULL, "Cannot get arguments for calling closure"); - RETVAL_FALSE; - } else if (call_user_function_ex(CG(function_table), NULL, getThis(), return_value, ZEND_NUM_ARGS(), arguments, 1, NULL) == FAILURE) { + if (call_user_function_ex(CG(function_table), NULL, getThis(), return_value, ZEND_NUM_ARGS(), arguments, 1, NULL) == FAILURE) { RETVAL_FALSE; } - efree(arguments); /* destruct the function also, then - we have allocated it in get_method */ zend_string_release(func->internal_function.function_name); @@ -388,23 +382,16 @@ static zend_object *zend_closure_clone(zval *zobject) /* {{{ */ int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr) /* {{{ */ { - zend_closure *closure; - - if (Z_TYPE_P(obj) != IS_OBJECT) { - return FAILURE; - } - - closure = (zend_closure *)Z_OBJ_P(obj); + zend_closure *closure = (zend_closure *)Z_OBJ_P(obj); *fptr_ptr = &closure->func; *ce_ptr = closure->called_scope; - if (obj_ptr) { - if (Z_TYPE(closure->this_ptr) != IS_UNDEF) { - *obj_ptr = Z_OBJ(closure->this_ptr); - } else { - *obj_ptr = NULL; - } + if (Z_TYPE(closure->this_ptr) != IS_UNDEF) { + *obj_ptr = Z_OBJ(closure->this_ptr); + } else { + *obj_ptr = NULL; } + return SUCCESS; } /* }}} */ @@ -523,7 +510,6 @@ void zend_register_closure_ce(void) /* {{{ */ memcpy(&closure_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); closure_handlers.free_obj = zend_closure_free_storage; - closure_handlers.clone_obj = NULL; closure_handlers.get_constructor = zend_closure_get_constructor; closure_handlers.get_method = zend_closure_get_method; closure_handlers.write_property = zend_closure_write_property; diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index da2c83c55e..3adcc55f4e 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -871,6 +871,7 @@ zend_string *zend_resolve_non_class_name( if (ZSTR_VAL(name)[0] == '\\') { /* Remove \ prefix (only relevant if this is a string rather than a label) */ + *is_fully_qualified = 1; return zend_string_init(ZSTR_VAL(name) + 1, ZSTR_LEN(name) - 1, 0); } @@ -3132,26 +3133,30 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ } /* }}} */ -ZEND_API zend_uchar zend_get_call_op(zend_uchar init_op, zend_function *fbc) /* {{{ */ +ZEND_API zend_uchar zend_get_call_op(const zend_op *init_op, zend_function *fbc) /* {{{ */ { - if (fbc) { + if (fbc && init_op->opcode == ZEND_INIT_FCALL) { if (fbc->type == ZEND_INTERNAL_FUNCTION) { - if (!zend_execute_internal && - !fbc->common.scope && - !(fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED|ZEND_ACC_HAS_TYPE_HINTS|ZEND_ACC_RETURN_REFERENCE))) { - return ZEND_DO_ICALL; + if (!zend_execute_internal) { + if (!(fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED|ZEND_ACC_HAS_TYPE_HINTS|ZEND_ACC_RETURN_REFERENCE))) { + return ZEND_DO_ICALL; + } else { + return ZEND_DO_FCALL_BY_NAME; + } } } else { - if (zend_execute_ex == execute_ex && - !fbc->common.scope && - !(fbc->common.fn_flags & ZEND_ACC_GENERATOR)) { - return ZEND_DO_UCALL; + if (zend_execute_ex == execute_ex) { + if (!(fbc->common.fn_flags & ZEND_ACC_GENERATOR)) { + return ZEND_DO_UCALL; + } else { + return ZEND_DO_FCALL_BY_NAME; + } } } } else if (zend_execute_ex == execute_ex && !zend_execute_internal && - (init_op == ZEND_INIT_FCALL_BY_NAME || - init_op == ZEND_INIT_NS_FCALL_BY_NAME)) { + (init_op->opcode == ZEND_INIT_FCALL_BY_NAME || + init_op->opcode == ZEND_INIT_NS_FCALL_BY_NAME)) { return ZEND_DO_FCALL_BY_NAME; } return ZEND_DO_FCALL; @@ -3177,7 +3182,7 @@ void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function * } call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0); - opline = zend_emit_op(result, zend_get_call_op(opline->opcode, fbc), NULL, NULL); + opline = zend_emit_op(result, zend_get_call_op(opline, fbc), NULL, NULL); opline->op1.num = call_flags; zend_do_extended_fcall_end(); @@ -3670,6 +3675,7 @@ void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type) /* {{ znode obj_node, method_node; zend_op *opline; + zend_function *fbc = NULL; if (is_this_fetch(obj_ast)) { obj_node.op_type = IS_UNUSED; @@ -3693,7 +3699,20 @@ void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type) /* {{ SET_NODE(opline->op2, &method_node); } - zend_compile_call_common(result, args_ast, NULL); + /* Check if this calls a known method on $this */ + if (opline->op1_type == IS_UNUSED && opline->op2_type == IS_CONST && + CG(active_class_entry) && zend_is_scope_known()) { + zend_string *lcname = Z_STR_P(CT_CONSTANT(opline->op2) + 1); + fbc = zend_hash_find_ptr(&CG(active_class_entry)->function_table, lcname); + + /* We only know the exact method that is being called if it is either private or final. + * Otherwise an overriding method in a child class may be called. */ + if (fbc && !(fbc->common.fn_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_FINAL))) { + fbc = NULL; + } + } + + zend_compile_call_common(result, args_ast, fbc); } /* }}} */ @@ -4523,7 +4542,7 @@ void zend_compile_try(zend_ast *ast) /* {{{ */ zend_ast_list *catches = zend_ast_get_list(ast->child[1]); zend_ast *finally_ast = ast->child[2]; - uint32_t i; + uint32_t i, j; zend_op *opline; uint32_t try_catch_offset; uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), catches->children, 0); @@ -4568,34 +4587,53 @@ void zend_compile_try(zend_ast *ast) /* {{{ */ for (i = 0; i < catches->children; ++i) { zend_ast *catch_ast = catches->child[i]; - zend_ast *class_ast = catch_ast->child[0]; + zend_ast_list *classes = zend_ast_get_list(catch_ast->child[0]); zend_ast *var_ast = catch_ast->child[1]; zend_ast *stmt_ast = catch_ast->child[2]; zval *var_name = zend_ast_get_zval(var_ast); zend_bool is_last_catch = (i + 1 == catches->children); + uint32_t *jmp_multicatch = safe_emalloc(sizeof(uint32_t), classes->children - 1, 0); uint32_t opnum_catch; - if (!zend_is_const_default_class_ref(class_ast)) { - zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement"); - } + CG(zend_lineno) = catch_ast->lineno; - opnum_catch = get_next_op_number(CG(active_op_array)); - if (i == 0) { - CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = opnum_catch; - } + for (j = 0; j < classes->children; j++) { - CG(zend_lineno) = catch_ast->lineno; + zend_ast *class_ast = classes->child[j]; + zend_bool is_last_class = (j + 1 == classes->children); - opline = get_next_op(CG(active_op_array)); - opline->opcode = ZEND_CATCH; - opline->op1_type = IS_CONST; - opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), - zend_resolve_class_name_ast(class_ast)); + if (!zend_is_const_default_class_ref(class_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement"); + } - opline->op2_type = IS_CV; - opline->op2.var = lookup_cv(CG(active_op_array), zend_string_copy(Z_STR_P(var_name))); - opline->result.num = is_last_catch; + opnum_catch = get_next_op_number(CG(active_op_array)); + if (i == 0 && j == 0) { + CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = opnum_catch; + } + + opline = get_next_op(CG(active_op_array)); + opline->opcode = ZEND_CATCH; + opline->op1_type = IS_CONST; + opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), + zend_resolve_class_name_ast(class_ast)); + + opline->op2_type = IS_CV; + opline->op2.var = lookup_cv(CG(active_op_array), zend_string_copy(Z_STR_P(var_name))); + + opline->result.num = is_last_catch && is_last_class; + + if (!is_last_class) { + jmp_multicatch[j] = zend_emit_jump(0); + opline->extended_value = get_next_op_number(CG(active_op_array)); + } + } + + for (j = 0; j < classes->children - 1; j++) { + zend_update_jump_target_to_next(jmp_multicatch[j]); + } + + efree(jmp_multicatch); zend_compile_stmt(stmt_ast); @@ -4899,8 +4937,9 @@ void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast) /* {{{ */ zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s", ZSTR_VAL(name)); } else if (zend_string_equals_literal(name, "this")) { - if (op_array->scope && (op_array->fn_flags & ZEND_ACC_STATIC) == 0) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); + if ((op_array->scope || (op_array->fn_flags & ZEND_ACC_CLOSURE)) + && (op_array->fn_flags & ZEND_ACC_STATIC) == 0) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as parameter"); } op_array->this_var = var_node.u.op.var; } @@ -5304,6 +5343,7 @@ static void zend_begin_func_decl(znode *result, zend_op_array *op_array, zend_as LITERAL_STR(opline->op1, zend_string_copy(lcname)); /* RTD key is placed after lcname literal in op1 */ zend_add_literal_string(CG(active_op_array), &key); + SET_UNUSED(opline->op2); } zend_string_release(lcname); @@ -5754,6 +5794,7 @@ void zend_compile_class_decl(zend_ast *ast) /* {{{ */ SET_NODE(opline->op2, &extends_node); } else { opline->opcode = ZEND_DECLARE_CLASS; + SET_UNUSED(opline->op2); } key = zend_build_runtime_definition_key(lcname, decl->lex_pos); @@ -7003,7 +7044,7 @@ void zend_compile_array(znode *result, zend_ast *ast) /* {{{ */ /* Add a flag to INIT_ARRAY if we know this array cannot be packed */ if (!packed) { - ZEND_ASSERT(opnum_init != -1); + ZEND_ASSERT(opnum_init != (uint32_t)-1); opline = &CG(active_op_array)->opcodes[opnum_init]; opline->extended_value |= ZEND_ARRAY_NOT_PACKED; } @@ -7267,11 +7308,11 @@ static void zend_compile_encaps_list(znode *result, zend_ast *ast) /* {{{ */ while (opline != init_opline) { opline--; if (opline->opcode == ZEND_ROPE_ADD && - opline->result.var == -1) { + opline->result.var == (uint32_t)-1) { opline->op1.var = var; opline->result.var = var; } else if (opline->opcode == ZEND_ROPE_INIT && - opline->result.var == -1) { + opline->result.var == (uint32_t)-1) { opline->result.var = var; } } @@ -7307,7 +7348,7 @@ zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) /* {{{ */ || kind == ZEND_AST_CONDITIONAL || kind == ZEND_AST_DIM || kind == ZEND_AST_ARRAY || kind == ZEND_AST_ARRAY_ELEM || kind == ZEND_AST_CONST || kind == ZEND_AST_CLASS_CONST - || kind == ZEND_AST_MAGIC_CONST; + || kind == ZEND_AST_MAGIC_CONST || kind == ZEND_AST_COALESCE; } /* }}} */ @@ -7441,14 +7482,16 @@ void zend_const_expr_to_zval(zval *result, zend_ast *ast) /* {{{ */ zend_compile_const_expr(&ast); if (ast->kind == ZEND_AST_ZVAL) { ZVAL_COPY_VALUE(result, zend_ast_get_zval(ast)); - - /* Kill this branch of the original AST, as it was already destroyed. - * It would be nice to find a better solution to this problem in the - * future. */ - orig_ast->kind = 0; } else { ZVAL_NEW_AST(result, zend_ast_copy(ast)); + /* destroy the ast here, it might have been replaced */ + zend_ast_destroy(ast); } + + /* Kill this branch of the original AST, as it was already destroyed. + * It would be nice to find a better solution to this problem in the + * future. */ + orig_ast->kind = 0; } /* }}} */ @@ -7859,6 +7902,30 @@ void zend_eval_const_expr(zend_ast **ast_ptr) /* {{{ */ return; } break; + case ZEND_AST_COALESCE: + /* Set isset fetch indicator here, opcache disallows runtime altering of the AST */ + if (ast->child[0]->kind == ZEND_AST_DIM) { + ast->child[0]->attr = ZEND_DIM_IS; + } + zend_eval_const_expr(&ast->child[0]); + + if (ast->child[0]->kind != ZEND_AST_ZVAL) { + /* ensure everything was compile-time evaluated at least once */ + zend_eval_const_expr(&ast->child[1]); + return; + } + + if (Z_TYPE_P(zend_ast_get_zval(ast->child[0])) == IS_NULL) { + zend_eval_const_expr(&ast->child[1]); + *ast_ptr = ast->child[1]; + ast->child[1] = NULL; + zend_ast_destroy(ast); + } else { + *ast_ptr = ast->child[0]; + ast->child[0] = NULL; + zend_ast_destroy(ast); + } + return; case ZEND_AST_CONDITIONAL: { zend_ast **child, *child_ast; @@ -7892,6 +7959,11 @@ void zend_eval_const_expr(zend_ast **ast_ptr) /* {{{ */ zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading"); } + /* Set isset fetch indicator here, opcache disallows runtime altering of the AST */ + if (ast->attr == ZEND_DIM_IS && ast->child[0]->kind == ZEND_AST_DIM) { + ast->child[0]->attr = ZEND_DIM_IS; + } + zend_eval_const_expr(&ast->child[0]); zend_eval_const_expr(&ast->child[1]); if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) { diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 833aeab297..f716dc51ff 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -421,6 +421,7 @@ typedef struct _zend_internal_function { union _zend_function { zend_uchar type; /* MUST be the first element of this struct! */ + uint32_t quick_arg_flags; struct { zend_uchar type; /* never used */ @@ -467,7 +468,7 @@ struct _zend_execute_data { #define ZEND_CALL_TOP (1 << 1) #define ZEND_CALL_FREE_EXTRA_ARGS (1 << 2) /* equal to IS_TYPE_REFCOUNTED */ #define ZEND_CALL_CTOR (1 << 3) -#define ZEND_CALL_FREE_SYMBOL_TABLE (1 << 4) +#define ZEND_CALL_HAS_SYMBOL_TABLE (1 << 4) #define ZEND_CALL_CLOSURE (1 << 5) #define ZEND_CALL_RELEASE_THIS (1 << 6) #define ZEND_CALL_ALLOCATED (1 << 7) @@ -786,7 +787,7 @@ ZEND_API zend_bool zend_is_compiling(void); ZEND_API char *zend_make_compiled_string_description(const char *name); ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers); uint32_t zend_get_class_fetch_type(zend_string *name); -ZEND_API zend_uchar zend_get_call_op(zend_uchar init_op, zend_function *fbc); +ZEND_API zend_uchar zend_get_call_op(const zend_op *init_op, zend_function *fbc); typedef zend_bool (*zend_auto_global_callback)(zend_string *name); typedef struct _zend_auto_global { @@ -896,6 +897,8 @@ ZEND_API void zend_assert_valid_class_name(const zend_string *const_name); #define ZEND_SEND_BY_REF 1 #define ZEND_SEND_PREFER_REF 2 +#define ZEND_DIM_IS 1 + static zend_always_inline int zend_check_arg_send_type(const zend_function *zf, uint32_t arg_num, uint32_t mask) { arg_num--; @@ -922,16 +925,16 @@ static zend_always_inline int zend_check_arg_send_type(const zend_function *zf, #ifdef WORDS_BIGENDIAN # define ZEND_SET_ARG_FLAG(zf, arg_num, mask) do { \ - *(uint32_t*)&(zf)->type |= ((mask) << ((arg_num) - 1) * 2); \ + (zf)->quick_arg_flags |= ((mask) << ((arg_num) - 1) * 2); \ } while (0) # define ZEND_CHECK_ARG_FLAG(zf, arg_num, mask) \ - (((*((uint32_t*)&((zf)->type))) >> (((arg_num) - 1) * 2)) & (mask)) + (((zf)->quick_arg_flags >> (((arg_num) - 1) * 2)) & (mask)) #else # define ZEND_SET_ARG_FLAG(zf, arg_num, mask) do { \ - *(uint32_t*)&(zf)->type |= (((mask) << 6) << (arg_num) * 2); \ + (zf)->quick_arg_flags |= (((mask) << 6) << (arg_num) * 2); \ } while (0) # define ZEND_CHECK_ARG_FLAG(zf, arg_num, mask) \ - (((*(uint32_t*)&(zf)->type) >> (((arg_num) + 3) * 2)) & (mask)) + (((zf)->quick_arg_flags >> (((arg_num) + 3) * 2)) & (mask)) #endif #define QUICK_ARG_MUST_BE_SENT_BY_REF(zf, arg_num) \ diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c index 0249d35626..3e09f0cbb8 100644 --- a/Zend/zend_constants.c +++ b/Zend/zend_constants.c @@ -311,7 +311,6 @@ ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, zend_constant *c; const char *colon; zend_class_entry *ce = NULL; - zend_string *class_name; const char *name = ZSTR_VAL(cname); size_t name_len = ZSTR_LEN(cname); @@ -327,77 +326,68 @@ ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, int class_name_len = colon - name - 1; size_t const_name_len = name_len - class_name_len - 2; zend_string *constant_name = zend_string_init(colon + 1, const_name_len, 0); - char *lcname; + zend_string *class_name = zend_string_init(name, class_name_len, 0); zval *ret_constant = NULL; - ALLOCA_FLAG(use_heap) - class_name = zend_string_init(name, class_name_len, 0); - lcname = do_alloca(class_name_len + 1, use_heap); - zend_str_tolower_copy(lcname, name, class_name_len); - if (!scope) { - if (EG(current_execute_data)) { - scope = EG(scope); - } else { - scope = CG(active_class_entry); - } - } - - if (class_name_len == sizeof("self")-1 && - !memcmp(lcname, "self", sizeof("self")-1)) { + if (zend_string_equals_literal_ci(class_name, "self")) { if (UNEXPECTED(!scope)) { zend_throw_error(NULL, "Cannot access self:: when no class scope is active"); - return NULL; + goto failure; } ce = scope; - } else if (class_name_len == sizeof("parent")-1 && - !memcmp(lcname, "parent", sizeof("parent")-1)) { + } else if (zend_string_equals_literal_ci(class_name, "parent")) { if (UNEXPECTED(!scope)) { zend_throw_error(NULL, "Cannot access parent:: when no class scope is active"); - return NULL; + goto failure; } else if (UNEXPECTED(!scope->parent)) { zend_throw_error(NULL, "Cannot access parent:: when current class scope has no parent"); - return NULL; + goto failure; } else { ce = scope->parent; } - } else if (class_name_len == sizeof("static")-1 && - !memcmp(lcname, "static", sizeof("static")-1)) { + } else if (zend_string_equals_literal_ci(class_name, "static")) { ce = zend_get_called_scope(EG(current_execute_data)); if (UNEXPECTED(!ce)) { zend_throw_error(NULL, "Cannot access static:: when no class scope is active"); - return NULL; + goto failure; } } else { ce = zend_fetch_class(class_name, flags); } - free_alloca(lcname, use_heap); if (ce) { zend_class_constant *c = zend_hash_find_ptr(&ce->constants_table, constant_name); if (c == NULL) { if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) { zend_throw_error(NULL, "Undefined class constant '%s::%s'", ZSTR_VAL(class_name), ZSTR_VAL(constant_name)); - zend_string_release(class_name); - zend_string_free(constant_name); - return NULL; + goto failure; } ret_constant = NULL; } else { if (!zend_verify_const_access(c, scope)) { zend_throw_error(NULL, "Cannot access %s const %s::%s", zend_visibility_string(Z_ACCESS_FLAGS(c->value)), ZSTR_VAL(class_name), ZSTR_VAL(constant_name)); - zend_string_release(class_name); - zend_string_free(constant_name); - return NULL; + goto failure; } ret_constant = &c->value; } } - zend_string_release(class_name); - zend_string_free(constant_name); + if (ret_constant && Z_CONSTANT_P(ret_constant)) { - if (UNEXPECTED(zval_update_constant_ex(ret_constant, 1, ce) != SUCCESS)) { - return NULL; + if (Z_TYPE_P(ret_constant) == IS_CONSTANT_AST) { + if (IS_CONSTANT_VISITED(ret_constant)) { + zend_throw_error(NULL, "Cannot declare self-referencing constant '%s::%s'", ZSTR_VAL(class_name), ZSTR_VAL(constant_name)); + goto failure; + } + MARK_CONSTANT_VISITED(ret_constant); } + if (UNEXPECTED(zval_update_constant_ex(ret_constant, ce) != SUCCESS)) { + RESET_CONSTANT_VISITED(ret_constant); + goto failure; + } + RESET_CONSTANT_VISITED(ret_constant); } +failure: + zend_string_release(class_name); + zend_string_free(constant_name); return ret_constant; } diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index 6d396e7854..63bcca2640 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -662,14 +662,15 @@ ZEND_METHOD(exception, __toString) zend_class_entry *base_ce; zend_string *str; zend_fcall_info fci; - zval fname, rv; + zval rv; + zend_string *fname; DEFAULT_0_PARAMS; str = ZSTR_EMPTY_ALLOC(); exception = getThis(); - ZVAL_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1); + fname = zend_string_init("gettraceasstring", sizeof("gettraceasstring")-1, 0); while (exception && Z_TYPE_P(exception) == IS_OBJECT && instanceof_function(Z_OBJCE_P(exception), zend_ce_throwable)) { zend_string *prev_str = str; @@ -678,8 +679,7 @@ ZEND_METHOD(exception, __toString) zend_long line = zval_get_long(GET_PROPERTY(exception, "line")); fci.size = sizeof(fci); - fci.function_table = &Z_OBJCE_P(exception)->function_table; - ZVAL_COPY_VALUE(&fci.function_name, &fname); + ZVAL_STR(&fci.function_name, fname); fci.object = Z_OBJ_P(exception); fci.retval = &trace; fci.param_count = 0; @@ -720,7 +720,7 @@ ZEND_METHOD(exception, __toString) exception = GET_PROPERTY(exception, "previous"); } - zval_dtor(&fname); + zend_string_release(fname); exception = getThis(); base_ce = i_get_exception_base(exception); diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 86df4f760e..8213164d24 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -75,7 +75,7 @@ static ZEND_FUNCTION(pass) { } -static const zend_internal_function zend_pass_function = { +ZEND_API const zend_internal_function zend_pass_function = { ZEND_INTERNAL_FUNCTION, /* type */ {0, 0, 0}, /* arg_flags */ 0, /* fn_flags */ @@ -86,7 +86,8 @@ static const zend_internal_function zend_pass_function = { 0, /* required_num_args */ NULL, /* arg_info */ ZEND_FN(pass), /* handler */ - NULL /* module */ + NULL, /* module */ + {NULL,NULL,NULL,NULL} /* reserved */ }; #undef zval_ptr_dtor @@ -385,6 +386,11 @@ static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_RW(const zend_exec return EX_VAR(var); } +static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_UNSET(const zend_execute_data *execute_data, uint32_t var) +{ + return EX_VAR(var); +} + static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_W(const zend_execute_data *execute_data, uint32_t var) { zval *ret = EX_VAR(var); @@ -612,7 +618,7 @@ static zend_always_inline zend_class_entry* zend_verify_arg_class_kind(const zen return zend_fetch_class(cur_arg_info->class_name, (ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD)); } -static ZEND_COLD void zend_verify_arg_error(const zend_function *zf, uint32_t arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind, zval *arg) +static ZEND_COLD void zend_verify_arg_error(const zend_function *zf, uint32_t arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind) { zend_execute_data *ptr = EG(current_execute_data)->prev_execute_data; const char *fname = ZSTR_VAL(zf->common.function_name); @@ -640,19 +646,19 @@ static ZEND_COLD void zend_verify_arg_error(const zend_function *zf, uint32_t ar } } -static int is_null_constant(zval *default_value) +static int is_null_constant(zend_class_entry *scope, zval *default_value) { if (Z_CONSTANT_P(default_value)) { zval constant; - ZVAL_COPY_VALUE(&constant, default_value); - if (UNEXPECTED(zval_update_constant_ex(&constant, 0, NULL) != SUCCESS)) { + ZVAL_COPY(&constant, default_value); + if (UNEXPECTED(zval_update_constant_ex(&constant, scope) != SUCCESS)) { return 0; } if (Z_TYPE(constant) == IS_NULL) { return 1; } - zval_dtor(&constant); + zval_ptr_dtor(&constant); } return 0; } @@ -738,25 +744,25 @@ static int zend_verify_internal_arg_type(zend_function *zf, uint32_t arg_num, zv if (cur_arg_info->class_name) { need_msg = zend_verify_internal_arg_class_kind((zend_internal_arg_info*)cur_arg_info, &class_name, &ce); if (!ce || !instanceof_function(Z_OBJCE_P(arg), ce)) { - zend_verify_arg_error(zf, arg_num, need_msg, class_name, "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name), arg); + zend_verify_arg_error(zf, arg_num, need_msg, class_name, "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name)); return 0; } } } else if (Z_TYPE_P(arg) != IS_NULL || !cur_arg_info->allow_null) { if (cur_arg_info->class_name) { need_msg = zend_verify_internal_arg_class_kind((zend_internal_arg_info*)cur_arg_info, &class_name, &ce); - zend_verify_arg_error(zf, arg_num, need_msg, class_name, zend_zval_type_name(arg), "", arg); + zend_verify_arg_error(zf, arg_num, need_msg, class_name, zend_zval_type_name(arg), ""); return 0; } else if (cur_arg_info->type_hint == IS_CALLABLE) { if (!zend_is_callable(arg, IS_CALLABLE_CHECK_SILENT, NULL)) { - zend_verify_arg_error(zf, arg_num, "be callable", "", zend_zval_type_name(arg), "", arg); + zend_verify_arg_error(zf, arg_num, "be callable", "", zend_zval_type_name(arg), ""); return 0; } } else if (cur_arg_info->type_hint == _IS_BOOL && EXPECTED(Z_TYPE_P(arg) == IS_FALSE || Z_TYPE_P(arg) == IS_TRUE)) { /* pass */ } else if (UNEXPECTED(!zend_verify_scalar_type_hint(cur_arg_info->type_hint, arg, ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data))))) { - zend_verify_arg_error(zf, arg_num, "be of the type ", zend_get_type_by_const(cur_arg_info->type_hint), zend_zval_type_name(arg), "", arg); + zend_verify_arg_error(zf, arg_num, "be of the type ", zend_get_type_by_const(cur_arg_info->type_hint), zend_zval_type_name(arg), ""); return 0; } } @@ -764,6 +770,23 @@ static int zend_verify_internal_arg_type(zend_function *zf, uint32_t arg_num, zv return 1; } +static zend_never_inline int zend_verify_internal_arg_types(zend_function *fbc, zend_execute_data *call) +{ + uint32_t i; + uint32_t num_args = ZEND_CALL_NUM_ARGS(call); + zval *p = ZEND_CALL_ARG(call, 1); + + for (i = 0; i < num_args; ++i) { + if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) { + EG(current_execute_data) = call->prev_execute_data; + zend_vm_stack_free_args(call); + return 0; + } + p++; + } + return 1; +} + static zend_always_inline int zend_verify_arg_type(zend_function *zf, uint32_t arg_num, zval *arg, zval *default_value, void **cache_slot) { zend_arg_info *cur_arg_info; @@ -787,7 +810,7 @@ static zend_always_inline int zend_verify_arg_type(zend_function *zf, uint32_t a } else { ce = zend_verify_arg_class_kind(cur_arg_info); if (UNEXPECTED(!ce)) { - zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name), arg); + zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name)); return 0; } *cache_slot = (void*)ce; @@ -796,11 +819,11 @@ static zend_always_inline int zend_verify_arg_type(zend_function *zf, uint32_t a need_msg = (ce->ce_flags & ZEND_ACC_INTERFACE) ? "implement interface " : "be an instance of "; - zend_verify_arg_error(zf, arg_num, need_msg, ZSTR_VAL(ce->name), "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name), arg); + zend_verify_arg_error(zf, arg_num, need_msg, ZSTR_VAL(ce->name), "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name)); return 0; } } - } else if (Z_TYPE_P(arg) != IS_NULL || !(cur_arg_info->allow_null || (default_value && is_null_constant(default_value)))) { + } else if (Z_TYPE_P(arg) != IS_NULL || !(cur_arg_info->allow_null || (default_value && is_null_constant(zf->common.scope, default_value)))) { if (cur_arg_info->class_name) { if (EXPECTED(*cache_slot)) { ce = (zend_class_entry*)*cache_slot; @@ -808,9 +831,9 @@ static zend_always_inline int zend_verify_arg_type(zend_function *zf, uint32_t a ce = zend_verify_arg_class_kind(cur_arg_info); if (UNEXPECTED(!ce)) { if (Z_TYPE_P(arg) == IS_OBJECT) { - zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name), arg); + zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name)); } else { - zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "", zend_zval_type_name(arg), arg); + zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "", zend_zval_type_name(arg)); } return 0; } @@ -819,18 +842,18 @@ static zend_always_inline int zend_verify_arg_type(zend_function *zf, uint32_t a need_msg = (ce->ce_flags & ZEND_ACC_INTERFACE) ? "implement interface " : "be an instance of "; - zend_verify_arg_error(zf, arg_num, need_msg, ZSTR_VAL(ce->name), zend_zval_type_name(arg), "", arg); + zend_verify_arg_error(zf, arg_num, need_msg, ZSTR_VAL(ce->name), zend_zval_type_name(arg), ""); return 0; } else if (cur_arg_info->type_hint == IS_CALLABLE) { if (!zend_is_callable(arg, IS_CALLABLE_CHECK_SILENT, NULL)) { - zend_verify_arg_error(zf, arg_num, "be callable", "", zend_zval_type_name(arg), "", arg); + zend_verify_arg_error(zf, arg_num, "be callable", "", zend_zval_type_name(arg), ""); return 0; } } else if (cur_arg_info->type_hint == _IS_BOOL && EXPECTED(Z_TYPE_P(arg) == IS_FALSE || Z_TYPE_P(arg) == IS_TRUE)) { /* pass */ } else if (UNEXPECTED(!zend_verify_scalar_type_hint(cur_arg_info->type_hint, arg, ZEND_ARG_USES_STRICT_TYPES()))) { - zend_verify_arg_error(zf, arg_num, "be of the type ", zend_get_type_by_const(cur_arg_info->type_hint), zend_zval_type_name(arg), "", arg); + zend_verify_arg_error(zf, arg_num, "be of the type ", zend_get_type_by_const(cur_arg_info->type_hint), zend_zval_type_name(arg), ""); return 0; } } @@ -859,7 +882,7 @@ static zend_always_inline int zend_verify_missing_arg_type(zend_function *zf, ui } else { ce = zend_verify_arg_class_kind(cur_arg_info); if (UNEXPECTED(!ce)) { - zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "none", "", NULL); + zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "none", ""); return 0; } *cache_slot = (void*)ce; @@ -867,11 +890,11 @@ static zend_always_inline int zend_verify_missing_arg_type(zend_function *zf, ui need_msg = (ce->ce_flags & ZEND_ACC_INTERFACE) ? "implement interface " : "be an instance of "; - zend_verify_arg_error(zf, arg_num, need_msg, ZSTR_VAL(ce->name), "none", "", NULL); + zend_verify_arg_error(zf, arg_num, need_msg, ZSTR_VAL(ce->name), "none", ""); } else if (cur_arg_info->type_hint == IS_CALLABLE) { - zend_verify_arg_error(zf, arg_num, "be callable", "", "none", "", NULL); + zend_verify_arg_error(zf, arg_num, "be callable", "", "none", ""); } else { - zend_verify_arg_error(zf, arg_num, "be of the type ", zend_get_type_by_const(cur_arg_info->type_hint), "none", "", NULL); + zend_verify_arg_error(zf, arg_num, "be of the type ", zend_get_type_by_const(cur_arg_info->type_hint), "none", ""); } return 0; } @@ -913,6 +936,7 @@ static ZEND_COLD void zend_verify_return_error(const zend_function *zf, const ch fclass, fsep, fname, need_msg, need_kind, returned_msg, returned_kind); } +#if ZEND_DEBUG static ZEND_COLD void zend_verify_internal_return_error(const zend_function *zf, const char *need_msg, const char *need_kind, const char *returned_msg, const char *returned_kind) { const char *fname = ZSTR_VAL(zf->common.function_name); @@ -949,7 +973,6 @@ static ZEND_COLD void zend_verify_void_return_error(const zend_function *zf, con fclass, fsep, fname, returned_msg, returned_kind); } -#if ZEND_DEBUG static int zend_verify_internal_return_type(zend_function *zf, zval *ret) { zend_arg_info *ret_info = zf->common.arg_info - 1; @@ -1086,35 +1109,14 @@ static ZEND_COLD int zend_verify_missing_return_type(zend_function *zf, void **c return 1; } -static zend_never_inline void zend_assign_to_object_dim(zval *retval, zval *object, zval *property_name, int value_type, znode_op value_op, const zend_execute_data *execute_data) +static zend_never_inline void zend_assign_to_object_dim(zval *object, zval *dim, zval *value) { - zend_free_op free_value; - zval *value = get_zval_ptr_deref(value_type, value_op, execute_data, &free_value, BP_VAR_R); - - /* Note: property_name in this case is really the array index! */ - if (!Z_OBJ_HT_P(object)->write_dimension) { + if (UNEXPECTED(!Z_OBJ_HT_P(object)->write_dimension)) { zend_throw_error(NULL, "Cannot use object as array"); - FREE_OP(free_value); return; } - /* separate our value if necessary */ - if (value_type == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(value))) { - Z_ADDREF_P(value); - } - } - - Z_OBJ_HT_P(object)->write_dimension(object, property_name, value); - - if (retval && EXPECTED(!EG(exception))) { - ZVAL_COPY(retval, value); - } - if (value_type == IS_CONST) { - zval_ptr_dtor_nogc(value); - } else { - FREE_OP(free_value); - } + Z_OBJ_HT_P(object)->write_dimension(object, dim, value); } static zend_never_inline void zend_binary_assign_op_obj_dim(zval *object, zval *property, zval *value, zval *retval, binary_op_type binary_op) @@ -1151,16 +1153,170 @@ static zend_never_inline void zend_binary_assign_op_obj_dim(zval *object, zval * } } -static void zend_assign_to_string_offset(zval *str, zend_long offset, zval *value, zval *result) +static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type) +{ + zend_long offset; + +try_again: + if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) { + switch(Z_TYPE_P(dim)) { + case IS_STRING: + if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) { + break; + } + if (type != BP_VAR_UNSET) { + zend_error(E_WARNING, "Illegal string offset '%s'", Z_STRVAL_P(dim)); + } + break; + case IS_UNDEF: + zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data)); + case IS_DOUBLE: + case IS_NULL: + case IS_FALSE: + case IS_TRUE: + zend_error(E_NOTICE, "String offset cast occurred"); + break; + case IS_REFERENCE: + dim = Z_REFVAL_P(dim); + goto try_again; + default: + zend_error(E_WARNING, "Illegal offset type"); + break; + } + + offset = _zval_get_long_func(dim); + } else { + offset = Z_LVAL_P(dim); + } + + return offset; +} + +static zend_never_inline ZEND_COLD void zend_wrong_string_offset(void) +{ + const char *msg = NULL; + const zend_op *opline = EG(current_execute_data)->opline; + const zend_op *end; + uint32_t var; + + switch (opline->opcode) { + case ZEND_ASSIGN_ADD: + case ZEND_ASSIGN_SUB: + case ZEND_ASSIGN_MUL: + case ZEND_ASSIGN_DIV: + case ZEND_ASSIGN_MOD: + case ZEND_ASSIGN_SL: + case ZEND_ASSIGN_SR: + case ZEND_ASSIGN_CONCAT: + case ZEND_ASSIGN_BW_OR: + case ZEND_ASSIGN_BW_AND: + case ZEND_ASSIGN_BW_XOR: + case ZEND_ASSIGN_POW: + msg = "Cannot use assign-op operators with string offsets"; + break; + case ZEND_FETCH_DIM_W: + case ZEND_FETCH_DIM_RW: + case ZEND_FETCH_DIM_FUNC_ARG: + case ZEND_FETCH_DIM_UNSET: + /* TODO: Encode the "reason" into opline->extended_value??? */ + var = opline->result.var; + opline++; + end = EG(current_execute_data)->func->op_array.opcodes + + EG(current_execute_data)->func->op_array.last; + while (opline < end) { + if (opline->op1_type == IS_VAR && opline->op1.var == var) { + switch (opline->opcode) { + case ZEND_ASSIGN_ADD: + case ZEND_ASSIGN_SUB: + case ZEND_ASSIGN_MUL: + case ZEND_ASSIGN_DIV: + case ZEND_ASSIGN_MOD: + case ZEND_ASSIGN_SL: + case ZEND_ASSIGN_SR: + case ZEND_ASSIGN_CONCAT: + case ZEND_ASSIGN_BW_OR: + case ZEND_ASSIGN_BW_AND: + case ZEND_ASSIGN_BW_XOR: + case ZEND_ASSIGN_POW: + if (opline->extended_value == ZEND_ASSIGN_OBJ) { + msg = "Cannot use string offset as an object"; + } else if (opline->extended_value == ZEND_ASSIGN_DIM) { + msg = "Cannot use string offset as an array"; + } else { + msg = "Cannot use assign-op operators with string offsets"; + } + break; + case ZEND_PRE_INC_OBJ: + case ZEND_PRE_DEC_OBJ: + case ZEND_POST_INC_OBJ: + case ZEND_POST_DEC_OBJ: + case ZEND_PRE_INC: + case ZEND_PRE_DEC: + case ZEND_POST_INC: + case ZEND_POST_DEC: + msg = "Cannot increment/decrement string offsets"; + break; + case ZEND_FETCH_DIM_W: + case ZEND_FETCH_DIM_RW: + case ZEND_FETCH_DIM_FUNC_ARG: + case ZEND_FETCH_DIM_UNSET: + case ZEND_ASSIGN_DIM: + msg = "Cannot use string offset as an array"; + break; + case ZEND_FETCH_OBJ_W: + case ZEND_FETCH_OBJ_RW: + case ZEND_FETCH_OBJ_FUNC_ARG: + case ZEND_FETCH_OBJ_UNSET: + case ZEND_ASSIGN_OBJ: + msg = "Cannot use string offset as an object"; + break; + case ZEND_ASSIGN_REF: + case ZEND_ADD_ARRAY_ELEMENT: + case ZEND_INIT_ARRAY: + msg = "Cannot create references to/from string offsets"; + break; + case ZEND_RETURN_BY_REF: + msg = "Cannot return string offsets by reference"; + break; + case ZEND_UNSET_DIM: + case ZEND_UNSET_OBJ: + msg = "Cannot unset string offsets"; + break; + case ZEND_YIELD: + msg = "Cannot yield string offsets by reference"; + break; + case ZEND_SEND_REF: + case ZEND_SEND_VAR_EX: + msg = "Only variables can be passed by reference"; + break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + break; + } + if (opline->op2_type == IS_VAR && opline->op2.var == var) { + ZEND_ASSERT(opline->opcode == ZEND_ASSIGN_REF); + msg = "Cannot create references to/from string offsets"; + break; + } + } + break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + ZEND_ASSERT(msg != NULL); + zend_throw_error(NULL, msg); +} + +static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, zval *value, zval *result) { zend_string *old_str; zend_uchar c; size_t string_len; + zend_long offset; + offset = zend_check_string_offset(dim, BP_VAR_W); if (offset < (zend_long)(-Z_STRLEN_P(str))) { /* Error on negative offset */ zend_error(E_WARNING, "Illegal string offset: " ZEND_LONG_FMT, offset); - zend_string_release(Z_STR_P(str)); if (result) { ZVAL_NULL(result); } @@ -1182,7 +1338,6 @@ static void zend_assign_to_string_offset(zval *str, zend_long offset, zval *valu if (string_len == 0) { /* Error on empty input string */ zend_error(E_WARNING, "Cannot assign an empty string to a string offset"); - zend_string_release(Z_STR_P(str)); if (result) { ZVAL_NULL(result); } @@ -1193,7 +1348,6 @@ static void zend_assign_to_string_offset(zval *str, zend_long offset, zval *valu offset += (zend_long)Z_STRLEN_P(str); } - old_str = Z_STR_P(str); if ((size_t)offset >= Z_STRLEN_P(str)) { /* Extend string if needed */ zend_long old_len = Z_STRLEN_P(str); @@ -1202,13 +1356,16 @@ static void zend_assign_to_string_offset(zval *str, zend_long offset, zval *valu memset(Z_STRVAL_P(str) + old_len, ' ', offset - old_len); Z_STRVAL_P(str)[offset+1] = 0; } else if (!Z_REFCOUNTED_P(str)) { + old_str = Z_STR_P(str); Z_STR_P(str) = zend_string_init(Z_STRVAL_P(str), Z_STRLEN_P(str), 0); Z_TYPE_INFO_P(str) = IS_STRING_EX; + zend_string_release(old_str); + } else { + SEPARATE_STRING(str); } Z_STRVAL_P(str)[offset] = c; - zend_string_release(old_str); if (result) { /* Return the new character */ if (CG(one_char_string)[c]) { @@ -1384,7 +1541,7 @@ static zend_always_inline HashTable *zend_get_target_symbol_table(zend_execute_d ht = &EG(symbol_table); } else { ZEND_ASSERT(fetch_type == ZEND_FETCH_LOCAL); - if (!EX(symbol_table)) { + if (!(EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE)) { zend_rebuild_symbol_table(); } ht = EX(symbol_table); @@ -1472,6 +1629,9 @@ str_index: } } else { switch (Z_TYPE_P(dim)) { + case IS_UNDEF: + zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data)); + /* break missing intentionally */ case IS_NULL: offset_key = ZSTR_EMPTY_ALLOC(); goto str_index; @@ -1500,169 +1660,24 @@ str_index: return retval; } -static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type) +static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_W(HashTable *ht, const zval *dim) { - zend_long offset; - -try_again: - if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) { - switch(Z_TYPE_P(dim)) { - case IS_STRING: - if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) { - break; - } - if (type != BP_VAR_UNSET) { - zend_error(E_WARNING, "Illegal string offset '%s'", Z_STRVAL_P(dim)); - } - break; - case IS_DOUBLE: - case IS_NULL: - case IS_FALSE: - case IS_TRUE: - zend_error(E_NOTICE, "String offset cast occurred"); - break; - case IS_REFERENCE: - dim = Z_REFVAL_P(dim); - goto try_again; - default: - zend_error(E_WARNING, "Illegal offset type"); - break; - } - - offset = zval_get_long(dim); - } else { - offset = Z_LVAL_P(dim); - } - - return offset; + return zend_fetch_dimension_address_inner(ht, dim, IS_TMP_VAR, BP_VAR_W); } -static zend_never_inline ZEND_COLD void zend_wrong_string_offset(void) +static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_W_CONST(HashTable *ht, const zval *dim) { - const char *msg = NULL; - const zend_op *opline = EG(current_execute_data)->opline; - const zend_op *end; - uint32_t var; - - switch (opline->opcode) { - case ZEND_ASSIGN_ADD: - case ZEND_ASSIGN_SUB: - case ZEND_ASSIGN_MUL: - case ZEND_ASSIGN_DIV: - case ZEND_ASSIGN_MOD: - case ZEND_ASSIGN_SL: - case ZEND_ASSIGN_SR: - case ZEND_ASSIGN_CONCAT: - case ZEND_ASSIGN_BW_OR: - case ZEND_ASSIGN_BW_AND: - case ZEND_ASSIGN_BW_XOR: - case ZEND_ASSIGN_POW: - msg = "Cannot use assign-op operators with string offsets"; - break; - case ZEND_FETCH_DIM_W: - case ZEND_FETCH_DIM_RW: - case ZEND_FETCH_DIM_FUNC_ARG: - case ZEND_FETCH_DIM_UNSET: - /* TODO: Encode the "reason" into opline->extended_value??? */ - var = opline->result.var; - opline++; - end = EG(current_execute_data)->func->op_array.opcodes + - EG(current_execute_data)->func->op_array.last; - while (opline < end) { - if (opline->op1_type == IS_VAR && opline->op1.var == var) { - switch (opline->opcode) { - case ZEND_ASSIGN_ADD: - case ZEND_ASSIGN_SUB: - case ZEND_ASSIGN_MUL: - case ZEND_ASSIGN_DIV: - case ZEND_ASSIGN_MOD: - case ZEND_ASSIGN_SL: - case ZEND_ASSIGN_SR: - case ZEND_ASSIGN_CONCAT: - case ZEND_ASSIGN_BW_OR: - case ZEND_ASSIGN_BW_AND: - case ZEND_ASSIGN_BW_XOR: - case ZEND_ASSIGN_POW: - if (opline->extended_value == ZEND_ASSIGN_OBJ) { - msg = "Cannot use string offset as an object"; - } else if (opline->extended_value == ZEND_ASSIGN_DIM) { - msg = "Cannot use string offset as an array"; - } else { - msg = "Cannot use assign-op operators with string offsets"; - } - break; - case ZEND_PRE_INC_OBJ: - case ZEND_PRE_DEC_OBJ: - case ZEND_POST_INC_OBJ: - case ZEND_POST_DEC_OBJ: - case ZEND_PRE_INC: - case ZEND_PRE_DEC: - case ZEND_POST_INC: - case ZEND_POST_DEC: - msg = "Cannot increment/decrement string offsets"; - break; - case ZEND_FETCH_DIM_W: - case ZEND_FETCH_DIM_RW: - case ZEND_FETCH_DIM_FUNC_ARG: - case ZEND_FETCH_DIM_UNSET: - case ZEND_ASSIGN_DIM: - msg = "Cannot use string offset as an array"; - break; - case ZEND_FETCH_OBJ_W: - case ZEND_FETCH_OBJ_RW: - case ZEND_FETCH_OBJ_FUNC_ARG: - case ZEND_FETCH_OBJ_UNSET: - case ZEND_ASSIGN_OBJ: - msg = "Cannot use string offset as an object"; - break; - case ZEND_ASSIGN_REF: - case ZEND_ADD_ARRAY_ELEMENT: - case ZEND_INIT_ARRAY: - msg = "Cannot create references to/from string offsets"; - break; - case ZEND_RETURN_BY_REF: - msg = "Cannot return string offsets by reference"; - break; - case ZEND_UNSET_DIM: - case ZEND_UNSET_OBJ: - msg = "Cannot unset string offsets"; - break; - case ZEND_YIELD: - msg = "Cannot yield string offsets by reference"; - break; - case ZEND_SEND_REF: - case ZEND_SEND_VAR_EX: - msg = "Only variables can be passed by reference"; - break; - EMPTY_SWITCH_DEFAULT_CASE(); - } - break; - } - if (opline->op2_type == IS_VAR && opline->op2.var == var) { - ZEND_ASSERT(opline->opcode == ZEND_ASSIGN_REF); - msg = "Cannot create references to/from string offsets"; - break; - } - } - break; - EMPTY_SWITCH_DEFAULT_CASE(); - } - ZEND_ASSERT(msg != NULL); - zend_throw_error(NULL, msg); + return zend_fetch_dimension_address_inner(ht, dim, IS_CONST, BP_VAR_W); } -static zend_always_inline zend_long zend_fetch_string_offset(zval *container, zval *dim, int type) +static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_RW(HashTable *ht, const zval *dim) { - zend_long offset = zend_check_string_offset(dim, type); + return zend_fetch_dimension_address_inner(ht, dim, IS_TMP_VAR, BP_VAR_RW); +} - if (Z_REFCOUNTED_P(container)) { - if (Z_REFCOUNT_P(container) > 1) { - Z_DELREF_P(container); - zval_copy_ctor_func(container); - } - Z_ADDREF_P(container); - } - return offset; +static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_RW_CONST(HashTable *ht, const zval *dim) +{ + return zend_fetch_dimension_address_inner(ht, dim, IS_CONST, BP_VAR_RW); } static zend_always_inline void zend_fetch_dimension_address(zval *result, zval *container, zval *dim, int dim_type, int type) @@ -1712,6 +1727,10 @@ convert_to_array: } ZVAL_ERROR(result); } else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (/*dim_type == IS_CV &&*/ dim && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { + zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data)); + dim = &EG(uninitialized_zval); + } if (!Z_OBJ_HT_P(container)->read_dimension) { zend_throw_error(NULL, "Cannot use object as array"); ZVAL_ERROR(result); @@ -1750,22 +1769,30 @@ convert_to_array: ZVAL_ERROR(result); } } - } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { - if (type != BP_VAR_UNSET) { - goto convert_to_array; - } else { - /* for read-mode only */ - ZVAL_NULL(result); - } - } else if (EXPECTED(Z_ISERROR_P(container))) { - ZVAL_ERROR(result); } else { - if (type == BP_VAR_UNSET) { - zend_error(E_WARNING, "Cannot unset offset in a non-array variable"); - ZVAL_NULL(result); - } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + if (type != BP_VAR_W && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + zval_undefined_cv(EG(current_execute_data)->opline->op1.var, EG(current_execute_data)); + } + if (/*dim_type == IS_CV &&*/ dim && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { + zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data)); + } + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + if (type != BP_VAR_UNSET) { + goto convert_to_array; + } else { + /* for read-mode only */ + ZVAL_NULL(result); + } + } else if (EXPECTED(Z_ISERROR_P(container))) { ZVAL_ERROR(result); + } else { + if (type == BP_VAR_UNSET) { + zend_error(E_WARNING, "Cannot unset offset in a non-array variable"); + ZVAL_NULL(result); + } else { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + ZVAL_ERROR(result); + } } } } @@ -1785,7 +1812,7 @@ static zend_never_inline void zend_fetch_dimension_address_UNSET(zval *result, z zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_UNSET); } -static zend_always_inline void zend_fetch_dimension_address_read(zval *result, zval *container, zval *dim, int dim_type, int type) +static zend_always_inline void zend_fetch_dimension_address_read(zval *result, zval *container, zval *dim, int dim_type, int type, int support_strings) { zval *retval; @@ -1800,7 +1827,7 @@ try_array: goto try_array; } } - if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (support_strings && EXPECTED(Z_TYPE_P(container) == IS_STRING)) { zend_long offset; try_string_offset: @@ -1817,6 +1844,8 @@ try_string_offset: } zend_error(E_WARNING, "Illegal string offset '%s'", Z_STRVAL_P(dim)); break; + case IS_UNDEF: + zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data)); case IS_DOUBLE: case IS_NULL: case IS_FALSE: @@ -1833,7 +1862,7 @@ try_string_offset: break; } - offset = zval_get_long(dim); + offset = _zval_get_long_func(dim); } else { offset = Z_LVAL_P(dim); } @@ -1860,6 +1889,10 @@ try_string_offset: } } } else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (/*dim_type == IS_CV &&*/ UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { + zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data)); + dim = &EG(uninitialized_zval); + } if (!Z_OBJ_HT_P(container)->read_dimension) { zend_throw_error(NULL, "Cannot use object as array"); ZVAL_NULL(result); @@ -1876,18 +1909,29 @@ try_string_offset: } } } else { + if (type != BP_VAR_IS && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + zval_undefined_cv(EG(current_execute_data)->opline->op1.var, EG(current_execute_data)); + } + if (/*dim_type == IS_CV &&*/ UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { + zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data)); + } ZVAL_NULL(result); } } static zend_never_inline void zend_fetch_dimension_address_read_R(zval *result, zval *container, zval *dim, int dim_type) { - zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_R); + zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_R, 1); } static zend_never_inline void zend_fetch_dimension_address_read_IS(zval *result, zval *container, zval *dim, int dim_type) { - zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_IS); + zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_IS, 1); +} + +static zend_never_inline void zend_fetch_dimension_address_read_LIST(zval *result, zval *container, zval *dim) +{ + zend_fetch_dimension_address_read(result, container, dim, IS_TMP_VAR, BP_VAR_R, 0); } ZEND_API void zend_fetch_dimension_by_zval(zval *result, zval *container, zval *dim) @@ -1895,6 +1939,12 @@ ZEND_API void zend_fetch_dimension_by_zval(zval *result, zval *container, zval * zend_fetch_dimension_address_read_R(result, container, dim, IS_TMP_VAR); } +ZEND_API void zend_fetch_dimension_by_zval_is(zval *result, zval *container, zval *dim, int dim_type) +{ + zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_IS, 1); +} + + static zend_always_inline void zend_fetch_property_address(zval *result, zval *container, uint32_t container_op_type, zval *prop_ptr, uint32_t prop_op_type, void **cache_slot, int type) { if (container_op_type != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -2057,16 +2107,17 @@ void zend_free_compiled_variables(zend_execute_data *execute_data) /* {{{ */ } /* }}} */ -#ifdef ZEND_WIN32 -# define ZEND_VM_INTERRUPT_CHECK() do { \ - if (EG(timed_out)) { \ - zend_timeout(0); \ +static zend_never_inline ZEND_COLD ZEND_NORETURN void ZEND_FASTCALL zend_interrupt(void) /* {{{ */ +{ + zend_timeout(0); +} +/* }}} */ + +#define ZEND_VM_INTERRUPT_CHECK() do { \ + if (UNEXPECTED(EG(timed_out))) { \ + zend_interrupt(); \ } \ } while (0) -#else -# define ZEND_VM_INTERRUPT_CHECK() do { \ - } while (0) -#endif /* * Stack Frame Layout (the whole stack frame is allocated at once) @@ -2155,7 +2206,6 @@ static zend_always_inline void i_init_func_execute_data(zend_execute_data *execu EX_LOAD_LITERALS(op_array); EG(current_execute_data) = execute_data; - ZEND_VM_INTERRUPT_CHECK(); } /* }}} */ @@ -2192,7 +2242,6 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu EX_LOAD_LITERALS(op_array); EG(current_execute_data) = execute_data; - ZEND_VM_INTERRUPT_CHECK(); } /* }}} */ @@ -2204,7 +2253,7 @@ static zend_always_inline void i_init_execute_data(zend_execute_data *execute_da EX(call) = NULL; EX(return_value) = return_value; - if (UNEXPECTED(EX(symbol_table) != NULL)) { + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { if (UNEXPECTED(op_array->this_var != (uint32_t)-1) && EXPECTED(Z_TYPE(EX(This)) == IS_OBJECT)) { GC_REFCOUNT(Z_OBJ(EX(This)))++; if (!zend_hash_str_add(EX(symbol_table), "this", sizeof("this")-1, &EX(This))) { @@ -2283,7 +2332,6 @@ static zend_always_inline void i_init_execute_data(zend_execute_data *execute_da EX_LOAD_LITERALS(op_array); EG(current_execute_data) = execute_data; - ZEND_VM_INTERRUPT_CHECK(); } /* }}} */ @@ -2334,8 +2382,6 @@ ZEND_API zend_execute_data *zend_create_generator_execute_data(zend_execute_data } while (arg_src != end); } - EX(symbol_table) = NULL; - if (UNEXPECTED(!op_array->run_time_cache)) { init_func_run_time_cache(op_array); } @@ -2614,6 +2660,342 @@ static void zend_swap_operands(zend_op *op) /* {{{ */ } /* }}} */ +static zend_never_inline zend_execute_data *zend_init_dynamic_call_string(zend_string *function, uint32_t num_args) /* {{{ */ +{ + zend_function *fbc; + zval *func; + zend_class_entry *called_scope; + zend_string *lcname; + const char *colon; + + if ((colon = zend_memrchr(ZSTR_VAL(function), ':', ZSTR_LEN(function))) != NULL && + colon > ZSTR_VAL(function) && + *(colon-1) == ':' + ) { + zend_string *mname; + size_t cname_length = colon - ZSTR_VAL(function) - 1; + size_t mname_length = ZSTR_LEN(function) - cname_length - (sizeof("::") - 1); + + lcname = zend_string_init(ZSTR_VAL(function), cname_length, 0); + + called_scope = zend_fetch_class_by_name(lcname, NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(called_scope == NULL)) { + zend_string_release(lcname); + return NULL; + } + + mname = zend_string_init(ZSTR_VAL(function) + (cname_length + sizeof("::") - 1), mname_length, 0); + + if (called_scope->get_static_method) { + fbc = called_scope->get_static_method(called_scope, mname); + } else { + fbc = zend_std_get_static_method(called_scope, mname, NULL); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), ZSTR_VAL(mname)); + } + zend_string_release(lcname); + zend_string_release(mname); + return NULL; + } + + zend_string_release(lcname); + zend_string_release(mname); + + if (UNEXPECTED(!(fbc->common.fn_flags & ZEND_ACC_STATIC))) { + if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { + zend_error(E_DEPRECATED, + "Non-static method %s::%s() should not be called statically", + ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + if (UNEXPECTED(EG(exception) != NULL)) { + return NULL; + } + } else { + zend_throw_error( + zend_ce_error, + "Non-static method %s::%s() cannot be called statically", + ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + return NULL; + } + } + } else { + if (ZSTR_VAL(function)[0] == '\\') { + lcname = zend_string_alloc(ZSTR_LEN(function) - 1, 0); + zend_str_tolower_copy(ZSTR_VAL(lcname), ZSTR_VAL(function) + 1, ZSTR_LEN(function) - 1); + } else { + lcname = zend_string_tolower(function); + } + if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) { + zend_throw_error(NULL, "Call to undefined function %s()", ZSTR_VAL(function)); + zend_string_release(lcname); + return NULL; + } + zend_string_release(lcname); + + fbc = Z_FUNC_P(func); + called_scope = NULL; + } + + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) { + init_func_run_time_cache(&fbc->op_array); + } + + return zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, + fbc, num_args, called_scope, NULL); +} +/* }}} */ + +static zend_never_inline zend_execute_data *zend_init_dynamic_call_object(zval *function, uint32_t num_args) /* {{{ */ +{ + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *object; + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION; + + if (EXPECTED(Z_OBJ_HANDLER_P(function, get_closure)) && + EXPECTED(Z_OBJ_HANDLER_P(function, get_closure)(function, &called_scope, &fbc, &object) == SUCCESS)) { + + if (fbc->common.fn_flags & ZEND_ACC_CLOSURE) { + /* Delay closure destruction until its invocation */ + ZEND_ASSERT(GC_TYPE((zend_object*)fbc->common.prototype) == IS_OBJECT); + GC_REFCOUNT((zend_object*)fbc->common.prototype)++; + call_info |= ZEND_CALL_CLOSURE; + } else if (object) { + call_info |= ZEND_CALL_RELEASE_THIS; + GC_REFCOUNT(object)++; /* For $this pointer */ + } + } else { + zend_throw_error(NULL, "Function name must be a string"); + return NULL; + } + + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) { + init_func_run_time_cache(&fbc->op_array); + } + + return zend_vm_stack_push_call_frame(call_info, + fbc, num_args, called_scope, object); +} +/* }}} */ + +static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_array *function, uint32_t num_args) /* {{{ */ +{ + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *object; + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION; + + if (zend_hash_num_elements(function) == 2) { + zval *obj; + zval *method; + obj = zend_hash_index_find(function, 0); + method = zend_hash_index_find(function, 1); + + if (UNEXPECTED(!obj) || UNEXPECTED(!method)) { + zend_throw_error(NULL, "Array callback has to contain indices 0 and 1"); + return NULL; + } + + ZVAL_DEREF(obj); + if (UNEXPECTED(Z_TYPE_P(obj) != IS_STRING) && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) { + zend_throw_error(NULL, "First array member is not a valid class name or object"); + return NULL; + } + + ZVAL_DEREF(method); + if (UNEXPECTED(Z_TYPE_P(method) != IS_STRING)) { + zend_throw_error(NULL, "Second array member is not a valid method"); + return NULL; + } + + if (Z_TYPE_P(obj) == IS_STRING) { + object = NULL; + called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(called_scope == NULL)) { + return NULL; + } + + 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); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), Z_STRVAL_P(method)); + } + return NULL; + } + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { + zend_error(E_DEPRECATED, + "Non-static method %s::%s() should not be called statically", + ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + if (UNEXPECTED(EG(exception) != NULL)) { + return NULL; + } + } else { + zend_throw_error( + zend_ce_error, + "Non-static method %s::%s() cannot be called statically", + ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + return NULL; + } + } + } else { + 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)) { + if (EXPECTED(!EG(exception))) { + zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(object->ce->name), Z_STRVAL_P(method)); + } + return NULL; + } + + if ((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { + object = NULL; + } else { + call_info |= ZEND_CALL_RELEASE_THIS; + GC_REFCOUNT(object)++; /* For $this pointer */ + } + } + } else { + zend_throw_error(NULL, "Function name must be a string"); + return NULL; + } + + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) { + init_func_run_time_cache(&fbc->op_array); + } + + return zend_vm_stack_push_call_frame(call_info, + fbc, num_args, called_scope, object); +} +/* }}} */ + +#define ZEND_FAKE_OP_ARRAY ((zend_op_array*)(zend_intptr_t)-1) + +static zend_never_inline zend_op_array* ZEND_FASTCALL zend_include_or_eval(zval *inc_filename, int type) /* {{{ */ +{ + zend_op_array *new_op_array = NULL; + zval tmp_inc_filename; + + ZVAL_UNDEF(&tmp_inc_filename); + if (Z_TYPE_P(inc_filename) != IS_STRING) { + ZVAL_STR(&tmp_inc_filename, zval_get_string(inc_filename)); + inc_filename = &tmp_inc_filename; + } + + if (type != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { + if (type == ZEND_INCLUDE_ONCE || type == ZEND_INCLUDE) { + zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename)); + } else { + zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename)); + } + } else { + switch (type) { + case ZEND_INCLUDE_ONCE: + case ZEND_REQUIRE_ONCE: { + zend_file_handle file_handle; + zend_string *resolved_path; + + resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), (int)Z_STRLEN_P(inc_filename)); + if (resolved_path) { + if (zend_hash_exists(&EG(included_files), resolved_path)) { + goto already_compiled; + } + } else { + resolved_path = zend_string_copy(Z_STR_P(inc_filename)); + } + + if (SUCCESS == zend_stream_open(ZSTR_VAL(resolved_path), &file_handle)) { + + if (!file_handle.opened_path) { + file_handle.opened_path = zend_string_copy(resolved_path); + } + + if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path)) { + zend_op_array *op_array = zend_compile_file(&file_handle, (type==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE)); + zend_destroy_file_handle(&file_handle); + zend_string_release(resolved_path); + if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) { + zend_string_release(Z_STR(tmp_inc_filename)); + } + return op_array; + } else { + zend_file_handle_dtor(&file_handle); +already_compiled: + new_op_array = ZEND_FAKE_OP_ARRAY; + } + } else { + if (type == ZEND_INCLUDE_ONCE) { + zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename)); + } else { + zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename)); + } + } + zend_string_release(resolved_path); + } + break; + case ZEND_INCLUDE: + case ZEND_REQUIRE: + new_op_array = compile_filename(type, inc_filename); + break; + case ZEND_EVAL: { + char *eval_desc = zend_make_compiled_string_description("eval()'d code"); + new_op_array = zend_compile_string(inc_filename, eval_desc); + efree(eval_desc); + } + break; + EMPTY_SWITCH_DEFAULT_CASE() + } + } + if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) { + zend_string_release(Z_STR(tmp_inc_filename)); + } + return new_op_array; +} +/* }}} */ + +static zend_never_inline int zend_do_fcall_overloaded(zend_function *fbc, zend_execute_data *call, zval *ret) /* {{{ */ +{ + zend_object *object; + + /* Not sure what should be done here if it's a static method */ + if (UNEXPECTED(Z_TYPE(call->This) != IS_OBJECT)) { + zend_vm_stack_free_args(call); + if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { + zend_string_release(fbc->common.function_name); + } + efree(fbc); + zend_vm_stack_free_call_frame(call); + + zend_throw_error(NULL, "Cannot call overloaded function for non-object"); + return 0; + } + + object = Z_OBJ(call->This); + + ZVAL_NULL(ret); + + EG(current_execute_data) = call; + object->handlers->call_method(fbc->common.function_name, object, call, ret); + EG(current_execute_data) = call->prev_execute_data; + + zend_vm_stack_free_args(call); + + if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { + zend_string_release(fbc->common.function_name); + } + efree(fbc); + + return 1; +} +/* }}} */ + #ifdef HAVE_GCC_GLOBAL_REGS # if defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(i386) # define ZEND_VM_FP_GLOBAL_REG "%esi" diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h index 738895e73c..36a44f6395 100644 --- a/Zend/zend_execute.h +++ b/Zend/zend_execute.h @@ -50,6 +50,9 @@ ZEND_API int zend_eval_stringl(char *str, size_t str_len, zval *retval_ptr, char ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, int handle_exceptions); ZEND_API int zend_eval_stringl_ex(char *str, size_t str_len, zval *retval_ptr, char *string_name, int handle_exceptions); +/* export zend_pass_function to allow comparisons against it */ +extern ZEND_API const zend_internal_function zend_pass_function; + ZEND_API void ZEND_FASTCALL zend_check_internal_arg_type(zend_function *zf, uint32_t arg_num, zval *arg); ZEND_API int ZEND_FASTCALL zend_check_arg_type(zend_function *zf, uint32_t arg_num, zval *arg, zval *default_value, void **cache_slot); ZEND_API void ZEND_FASTCALL zend_check_missing_arg(zend_execute_data *execute_data, uint32_t arg_num, void **cache_slot); @@ -122,8 +125,8 @@ static zend_always_inline zval* zend_assign_to_variable(zval *variable_ptr, zval return variable_ptr; } -ZEND_API int zval_update_constant(zval *pp, zend_bool inline_change); -ZEND_API int zval_update_constant_ex(zval *pp, zend_bool inline_change, zend_class_entry *scope); +ZEND_API int zval_update_constant(zval *pp); +ZEND_API int zval_update_constant_ex(zval *pp, zend_class_entry *scope); /* dedicated Zend executor functions - do not use! */ struct _zend_vm_stack { @@ -284,16 +287,18 @@ ZEND_API const char *get_active_function_name(void); ZEND_API const char *zend_get_executed_filename(void); ZEND_API zend_string *zend_get_executed_filename_ex(void); ZEND_API uint zend_get_executed_lineno(void); +ZEND_API zend_class_entry *zend_get_executed_scope(void); ZEND_API zend_bool zend_is_executing(void); ZEND_API void zend_set_timeout(zend_long seconds, int reset_signals); ZEND_API void zend_unset_timeout(void); -ZEND_API void zend_timeout(int dummy); +ZEND_API ZEND_NORETURN void zend_timeout(int dummy); ZEND_API zend_class_entry *zend_fetch_class(zend_string *class_name, int fetch_type); ZEND_API zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zval *key, int fetch_type); void zend_verify_abstract_class(zend_class_entry *ce); ZEND_API void zend_fetch_dimension_by_zval(zval *result, zval *container, zval *dim); +ZEND_API void zend_fetch_dimension_by_zval_is(zval *result, zval *container, zval *dim, int dim_type); ZEND_API zval* zend_get_compiled_variable_value(const zend_execute_data *execute_data_ptr, uint32_t var); diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index a4d82544f9..794c7f0fc9 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -38,12 +38,15 @@ #ifdef HAVE_SYS_TIME_H #include <sys/time.h> #endif +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif ZEND_API void (*zend_execute_ex)(zend_execute_data *execute_data); ZEND_API void (*zend_execute_internal)(zend_execute_data *execute_data, zval *return_value); /* true globals */ -ZEND_API const zend_fcall_info empty_fcall_info = { 0, NULL, {{0}, {{0}}, {0}}, NULL, NULL, NULL, 0, 0 }; +ZEND_API const zend_fcall_info empty_fcall_info = { 0, {{0}, {{0}}, {0}}, NULL, NULL, NULL, 0, 0 }; ZEND_API const zend_fcall_info_cache empty_fcall_info_cache = { 0, NULL, NULL, NULL, NULL }; #ifdef ZEND_WIN32 @@ -169,14 +172,12 @@ void init_executor(void) /* {{{ */ zend_objects_store_init(&EG(objects_store), 1024); EG(full_tables_cleanup) = 0; -#ifdef ZEND_WIN32 EG(timed_out) = 0; -#endif EG(exception) = NULL; EG(prev_exception) = NULL; - EG(scope) = NULL; + EG(fake_scope) = NULL; EG(ht_iterators_count) = sizeof(EG(ht_iterators_slots)) / sizeof(HashTableIterator); EG(ht_iterators_used) = 0; @@ -522,6 +523,21 @@ ZEND_API uint zend_get_executed_lineno(void) /* {{{ */ } /* }}} */ +ZEND_API zend_class_entry *zend_get_executed_scope(void) /* {{{ */ +{ + zend_execute_data *ex = EG(current_execute_data); + + while (1) { + if (!ex) { + return NULL; + } else if (ex->func && (ZEND_USER_CODE(ex->func->type) || ex->func->common.scope)) { + return ex->func->common.scope; + } + ex = ex->prev_execute_data; + } +} +/* }}} */ + ZEND_API zend_bool zend_is_executing(void) /* {{{ */ { return EG(current_execute_data) != 0; @@ -545,21 +561,18 @@ ZEND_API void _zval_internal_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ * } /* }}} */ -#define IS_VISITED_CONSTANT 0x80 -#define IS_CONSTANT_VISITED(p) (Z_TYPE_P(p) & IS_VISITED_CONSTANT) -#define MARK_CONSTANT_VISITED(p) Z_TYPE_INFO_P(p) |= IS_VISITED_CONSTANT -#define RESET_CONSTANT_VISITED(p) Z_TYPE_INFO_P(p) &= ~IS_VISITED_CONSTANT - -ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_class_entry *scope) /* {{{ */ +ZEND_API int zval_update_constant_ex(zval *p, zend_class_entry *scope) /* {{{ */ { zval *const_value; char *colon; + zend_bool inline_change; - if (IS_CONSTANT_VISITED(p)) { - zend_throw_error(NULL, "Cannot declare self-referencing constant '%s'", Z_STRVAL_P(p)); - return FAILURE; - } else if (Z_TYPE_P(p) == IS_CONSTANT) { - + if (Z_TYPE_P(p) == IS_CONSTANT) { + if (IS_CONSTANT_VISITED(p)) { + zend_throw_error(NULL, "Cannot declare self-referencing constant '%s'", Z_STRVAL_P(p)); + return FAILURE; + } + inline_change = (Z_TYPE_FLAGS_P(p) & IS_TYPE_IMMUTABLE) == 0; SEPARATE_ZVAL_NOREF(p); MARK_CONSTANT_VISITED(p); if (Z_CONST_FLAGS_P(p) & IS_CONSTANT_CLASS) { @@ -567,8 +580,8 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas if (inline_change) { zend_string_release(Z_STR_P(p)); } - if (EG(scope) && EG(scope)->name) { - ZVAL_STR_COPY(p, EG(scope)->name); + if (scope && scope->name) { + ZVAL_STR_COPY(p, scope->name); } else { ZVAL_EMPTY_STRING(p); } @@ -595,21 +608,8 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas Z_TYPE_FLAGS_P(p) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; } } - if (actual[0] == '\\') { - if (inline_change) { - memmove(Z_STRVAL_P(p), Z_STRVAL_P(p)+1, Z_STRLEN_P(p)); - --Z_STRLEN_P(p); - } else { - ++actual; - } - --actual_len; - } if ((Z_CONST_FLAGS_P(p) & IS_CONSTANT_UNQUALIFIED) == 0) { - if (ZSTR_VAL(save)[0] == '\\') { - zend_throw_error(NULL, "Undefined constant '%s'", ZSTR_VAL(save) + 1); - } else { - zend_throw_error(NULL, "Undefined constant '%s'", ZSTR_VAL(save)); - } + zend_throw_error(NULL, "Undefined constant '%s'", ZSTR_VAL(save)); if (inline_change) { zend_string_release(save); } @@ -633,17 +633,12 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas zend_string_release(Z_STR_P(p)); } ZVAL_COPY_VALUE(p, const_value); - if (Z_OPT_CONSTANT_P(p)) { - if (UNEXPECTED(zval_update_constant_ex(p, 1, NULL) != SUCCESS)) { - RESET_CONSTANT_VISITED(p); - return FAILURE; - } - } zval_opt_copy_ctor(p); } } else if (Z_TYPE_P(p) == IS_CONSTANT_AST) { zval tmp; + inline_change = (Z_TYPE_FLAGS_P(p) & IS_TYPE_IMMUTABLE) == 0; if (UNEXPECTED(zend_ast_evaluate(&tmp, Z_ASTVAL_P(p), scope) != SUCCESS)) { return FAILURE; } @@ -656,24 +651,17 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas } /* }}} */ -ZEND_API int zval_update_constant(zval *pp, zend_bool inline_change) /* {{{ */ +ZEND_API int zval_update_constant(zval *pp) /* {{{ */ { - return zval_update_constant_ex(pp, inline_change, NULL); + return zval_update_constant_ex(pp, EG(current_execute_data) ? zend_get_executed_scope() : CG(active_class_entry)); } /* }}} */ -int call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[]) /* {{{ */ -{ - return call_user_function_ex(function_table, object, function_name, retval_ptr, param_count, params, 1, NULL); -} -/* }}} */ - -int _call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], int no_separation) /* {{{ */ +int _call_user_function_ex(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], int no_separation) /* {{{ */ { zend_fcall_info fci; fci.size = sizeof(fci); - fci.function_table = function_table; fci.object = object ? Z_OBJ_P(object) : NULL; ZVAL_COPY_VALUE(&fci.function_name, function_name); fci.retval = retval_ptr; @@ -688,11 +676,9 @@ int _call_user_function_ex(HashTable *function_table, zval *object, zval *functi int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) /* {{{ */ { uint32_t i; - zend_class_entry *calling_scope = NULL; zend_execute_data *call, dummy_execute_data; zend_fcall_info_cache fci_cache_local; zend_function *func; - zend_class_entry *orig_scope; ZVAL_UNDEF(fci->retval); @@ -712,8 +698,6 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / break; } - orig_scope = EG(scope); - /* Initialize execute_data */ if (!EG(current_execute_data)) { /* This only happens when we're called outside any execute()'s @@ -769,7 +753,6 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / } func = fci_cache->function_handler; - calling_scope = fci_cache->calling_scope; fci->object = (func->common.fn_flags & ZEND_ACC_STATIC) ? NULL : fci_cache->object; @@ -787,6 +770,9 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / if (func->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) { if (func->common.fn_flags & ZEND_ACC_ABSTRACT) { zend_throw_error(NULL, "Cannot call abstract method %s::%s()", ZSTR_VAL(func->common.scope->name), ZSTR_VAL(func->common.function_name)); + if (EG(current_execute_data) == &dummy_execute_data) { + EG(current_execute_data) = dummy_execute_data.prev_execute_data; + } return FAILURE; } if (func->common.fn_flags & ZEND_ACC_DEPRECATED) { @@ -840,8 +826,6 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / ZVAL_COPY_VALUE(param, arg); } - EG(scope) = calling_scope; - if (UNEXPECTED(func->op_array.fn_flags & ZEND_ACC_CLOSURE)) { ZEND_ASSERT(GC_TYPE((zend_object*)func->op_array.prototype) == IS_OBJECT); GC_REFCOUNT((zend_object*)func->op_array.prototype)++; @@ -850,8 +834,6 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / if (func->type == ZEND_USER_FUNCTION) { int call_via_handler = (func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) != 0; - EG(scope) = func->common.scope; - call->symbol_table = NULL; if (EXPECTED((func->op_array.fn_flags & ZEND_ACC_GENERATOR) == 0)) { zend_init_execute_data(call, &func->op_array, fci->retval); zend_execute_ex(call); @@ -865,9 +847,6 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / } else if (func->type == ZEND_INTERNAL_FUNCTION) { int call_via_handler = (func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) != 0; ZVAL_NULL(fci->retval); - if (func->common.scope) { - EG(scope) = func->common.scope; - } call->prev_execute_data = EG(current_execute_data); call->return_value = NULL; /* this is not a constructor call */ EG(current_execute_data) = call; @@ -921,7 +900,6 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / } } - EG(scope) = orig_scope; zend_vm_stack_free_call_frame(call); if (EG(current_execute_data) == &dummy_execute_data) { @@ -1019,7 +997,6 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *k } fcall_info.size = sizeof(fcall_info); - fcall_info.function_table = EG(function_table); ZVAL_STR_COPY(&fcall_info.function_name, EG(autoload_func)->common.function_name); fcall_info.retval = &local_retval; fcall_info.param_count = 1; @@ -1180,8 +1157,47 @@ ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, } /* }}} */ -ZEND_API void zend_timeout(int dummy) /* {{{ */ +static void zend_set_timeout_ex(zend_long seconds, int reset_signals); + +ZEND_API ZEND_NORETURN void zend_timeout(int dummy) /* {{{ */ { + EG(timed_out) = 0; + zend_set_timeout_ex(0, 1); + zend_error_noreturn(E_ERROR, "Maximum execution time of %pd second%s exceeded", EG(timeout_seconds), EG(timeout_seconds) == 1 ? "" : "s"); +} +/* }}} */ + +#ifndef ZEND_WIN32 +static void zend_timeout_handler(int dummy) /* {{{ */ +{ +#ifndef ZTS + if (EG(timed_out)) { + /* Die on hard timeout */ + const char *error_filename = NULL; + uint error_lineno = 0; + char *log_buffer = NULL; + + if (zend_is_compiling()) { + error_filename = ZSTR_VAL(zend_get_compiled_filename()); + error_lineno = zend_get_compiled_lineno(); + } else if (zend_is_executing()) { + error_filename = zend_get_executed_filename(); + if (error_filename[0] == '[') { /* [no active file] */ + error_filename = NULL; + error_lineno = 0; + } else { + error_lineno = zend_get_executed_lineno(); + } + } + if (!error_filename) { + error_filename = "Unknown"; + } + + zend_spprintf(&log_buffer, 0, "\nFatal error: Maximum execution time of %pd+%pd seconds exceeded (terminated) in %s on line %d\n", EG(timeout_seconds), EG(hard_timeout), error_filename, error_lineno); + write(2, log_buffer, strlen(log_buffer)); + _exit(1); + } +#endif if (zend_on_timeout) { #ifdef ZEND_SIGNALS @@ -1196,9 +1212,17 @@ ZEND_API void zend_timeout(int dummy) /* {{{ */ zend_on_timeout(EG(timeout_seconds)); } - zend_error_noreturn(E_ERROR, "Maximum execution time of %pd second%s exceeded", EG(timeout_seconds), EG(timeout_seconds) == 1 ? "" : "s"); + EG(timed_out) = 1; + +#ifndef ZTS + if (EG(hard_timeout) > 0) { + /* Set hard timeout */ + zend_set_timeout_ex(EG(hard_timeout), 1); + } +#endif } /* }}} */ +#endif #ifdef ZEND_WIN32 VOID CALLBACK tq_timer_cb(PVOID arg, BOOLEAN timed_out) @@ -1221,11 +1245,9 @@ VOID CALLBACK tq_timer_cb(PVOID arg, BOOLEAN timed_out) #define SIGPROF 27 #endif -void zend_set_timeout(zend_long seconds, int reset_signals) /* {{{ */ +static void zend_set_timeout_ex(zend_long seconds, int reset_signals) /* {{{ */ { - EG(timeout_seconds) = seconds; - #ifdef ZEND_WIN32 if(!seconds) { return; @@ -1236,7 +1258,6 @@ void zend_set_timeout(zend_long seconds, int reset_signals) /* {{{ */ delete and recreate. */ if (NULL != tq_timer) { if (!DeleteTimerQueueTimer(NULL, tq_timer, NULL)) { - EG(timed_out) = 0; tq_timer = NULL; zend_error_noreturn(E_ERROR, "Could not delete queued timer"); return; @@ -1246,12 +1267,10 @@ void zend_set_timeout(zend_long seconds, int reset_signals) /* {{{ */ /* XXX passing NULL means the default timer queue provided by the system is used */ if (!CreateTimerQueueTimer(&tq_timer, NULL, (WAITORTIMERCALLBACK)tq_timer_cb, (VOID*)&EG(timed_out), seconds*1000, 0, WT_EXECUTEONLYONCE)) { - EG(timed_out) = 0; tq_timer = NULL; zend_error_noreturn(E_ERROR, "Could not queue new timer"); return; } - EG(timed_out) = 0; #else # ifdef HAVE_SETITIMER { @@ -1274,15 +1293,23 @@ void zend_set_timeout(zend_long seconds, int reset_signals) /* {{{ */ if (reset_signals) { # ifdef ZEND_SIGNALS - zend_signal(signo, zend_timeout); + zend_signal(signo, zend_timeout_handler); # else sigset_t sigset; - - signal(signo, zend_timeout); +# ifdef HAVE_SIGACTION + struct sigaction act; + + act.sa_handler = zend_timeout_handler; + sigemptyset(&act.sa_mask); + act.sa_flags = SA_RESETHAND | SA_NODEFER; + sigaction(signo, &act, NULL); +# else + signal(signo, zend_timeout_handler); +# endif /* HAVE_SIGACTION */ sigemptyset(&sigset); sigaddset(&sigset, signo); sigprocmask(SIG_UNBLOCK, &sigset, NULL); -# endif +# endif /* ZEND_SIGNALS */ } } # endif /* HAVE_SETITIMER */ @@ -1290,6 +1317,15 @@ void zend_set_timeout(zend_long seconds, int reset_signals) /* {{{ */ } /* }}} */ +void zend_set_timeout(zend_long seconds, int reset_signals) /* {{{ */ +{ + + EG(timeout_seconds) = seconds; + zend_set_timeout_ex(seconds, reset_signals); + EG(timed_out) = 0; +} +/* }}} */ + void zend_unset_timeout(void) /* {{{ */ { #ifdef ZEND_WIN32 @@ -1317,31 +1353,34 @@ void zend_unset_timeout(void) /* {{{ */ #endif } # endif + EG(timed_out) = 0; #endif } /* }}} */ zend_class_entry *zend_fetch_class(zend_string *class_name, int fetch_type) /* {{{ */ { - zend_class_entry *ce; + zend_class_entry *ce, *scope; int fetch_sub_type = fetch_type & ZEND_FETCH_CLASS_MASK; check_fetch_type: switch (fetch_sub_type) { case ZEND_FETCH_CLASS_SELF: - if (UNEXPECTED(!EG(scope))) { + scope = zend_get_executed_scope(); + if (UNEXPECTED(!scope)) { zend_throw_or_error(fetch_type, NULL, "Cannot access self:: when no class scope is active"); } - return EG(scope); + return scope; case ZEND_FETCH_CLASS_PARENT: - if (UNEXPECTED(!EG(scope))) { + scope = zend_get_executed_scope(); + if (UNEXPECTED(!scope)) { zend_throw_or_error(fetch_type, NULL, "Cannot access parent:: when no class scope is active"); return NULL; } - if (UNEXPECTED(!EG(scope)->parent)) { + if (UNEXPECTED(!scope->parent)) { zend_throw_or_error(fetch_type, NULL, "Cannot access parent:: when current class scope has no parent"); } - return EG(scope)->parent; + return scope->parent; case ZEND_FETCH_CLASS_STATIC: ce = zend_get_called_scope(EG(current_execute_data)); if (UNEXPECTED(!ce)) { @@ -1476,11 +1515,11 @@ ZEND_API zend_array *zend_rebuild_symbol_table(void) /* {{{ */ if (!ex) { return NULL; } - if (ex->symbol_table) { + if (ZEND_CALL_INFO(ex) & ZEND_CALL_HAS_SYMBOL_TABLE) { return ex->symbol_table; } - ZEND_ADD_CALL_FLAG(ex, ZEND_CALL_FREE_SYMBOL_TABLE); + ZEND_ADD_CALL_FLAG(ex, ZEND_CALL_HAS_SYMBOL_TABLE); if (EG(symtable_cache_ptr) >= EG(symtable_cache)) { /*printf("Cache hit! Reusing %x\n", symtable_cache[symtable_cache_ptr]);*/ symbol_table = ex->symbol_table = *(EG(symtable_cache_ptr)--); @@ -1581,7 +1620,7 @@ ZEND_API int zend_set_local_var(zend_string *name, zval *value, int force) /* {{ } if (execute_data) { - if (!execute_data->symbol_table) { + if (!(EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE)) { zend_ulong h = zend_string_hash_val(name); zend_op_array *op_array = &execute_data->func->op_array; @@ -1623,7 +1662,7 @@ ZEND_API int zend_set_local_var_str(const char *name, size_t len, zval *value, i } if (execute_data) { - if (!execute_data->symbol_table) { + if (!(EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE)) { zend_ulong h = zend_hash_func(name, len); zend_op_array *op_array = &execute_data->func->op_array; if (EXPECTED(op_array->last_var)) { diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c index e2cc2382bd..b4dfeba1da 100644 --- a/Zend/zend_generators.c +++ b/Zend/zend_generators.c @@ -64,7 +64,7 @@ ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished if (EXPECTED(generator->execute_data)) { zend_execute_data *execute_data = generator->execute_data; - if (execute_data->symbol_table) { + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { zend_clean_and_cache_symbol_table(execute_data->symbol_table); } /* always free the CV's, in the symtable are only not-free'd IS_INDIRECT's */ @@ -208,7 +208,7 @@ static uint32_t calc_gc_buffer_size(zend_generator *generator) /* {{{ */ zend_op_array *op_array = &EX(func)->op_array; /* Compiled variables */ - if (!execute_data->symbol_table) { + if (!(EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE)) { size += op_array->last_var; } /* Extra args */ @@ -220,10 +220,10 @@ static uint32_t calc_gc_buffer_size(zend_generator *generator) /* {{{ */ /* Yield from root references */ if (generator->node.children == 0) { - zend_generator *root = generator->node.ptr.root; - while (root != generator) { + zend_generator *child = generator, *root = generator->node.ptr.root; + while (root != child) { + child = child->node.parent; size++; - root = zend_generator_get_child(&root->node, generator); } } } @@ -262,7 +262,7 @@ static HashTable *zend_generator_get_gc(zval *object, zval **table, int *n) /* { ZVAL_COPY_VALUE(gc_buffer++, &generator->retval); ZVAL_COPY_VALUE(gc_buffer++, &generator->values); - if (!execute_data->symbol_table) { + if (!(EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE)) { uint32_t i, num_cvs = EX(func)->op_array.last_var; for (i = 0; i < num_cvs; i++) { ZVAL_COPY_VALUE(gc_buffer++, EX_VAR_NUM(i)); @@ -287,12 +287,16 @@ static HashTable *zend_generator_get_gc(zval *object, zval **table, int *n) /* { if (generator->node.children == 0) { zend_generator *child = generator, *root = generator->node.ptr.root; while (root != child) { - ZVAL_OBJ(gc_buffer++, &child->std); child = child->node.parent; + ZVAL_OBJ(gc_buffer++, &child->std); } } - return execute_data->symbol_table; + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { + return execute_data->symbol_table; + } else { + return NULL; + } } /* }}} */ @@ -321,7 +325,7 @@ static zend_object *zend_generator_create(zend_class_entry *class_type) /* {{{ * } /* }}} */ -/* Requires globals EG(scope), EG(This) and EG(current_execute_data). */ +/* Requires globals EG(current_execute_data). */ ZEND_API void zend_generator_create_zval(zend_execute_data *call, zend_op_array *op_array, zval *return_value) /* {{{ */ { zend_generator *generator; @@ -761,13 +765,11 @@ try_again: { /* Backup executor globals */ zend_execute_data *original_execute_data = EG(current_execute_data); - zend_class_entry *original_scope = EG(scope); zend_vm_stack original_stack = EG(vm_stack); original_stack->top = EG(vm_stack_top); /* Set executor globals */ EG(current_execute_data) = generator->execute_data; - EG(scope) = generator->execute_data->func->common.scope; EG(vm_stack_top) = generator->stack->top; EG(vm_stack_end) = generator->stack->end; EG(vm_stack) = generator->stack; @@ -797,7 +799,6 @@ try_again: /* Restore executor globals */ EG(current_execute_data) = original_execute_data; - EG(scope) = original_scope; EG(vm_stack_top) = original_stack->top; EG(vm_stack_end) = original_stack->end; EG(vm_stack) = original_stack; @@ -826,7 +827,7 @@ try_again: } /* }}} */ -static void inline zend_generator_ensure_initialized(zend_generator *generator) /* {{{ */ +static inline void zend_generator_ensure_initialized(zend_generator *generator) /* {{{ */ { if (UNEXPECTED(Z_TYPE(generator->value) == IS_UNDEF) && EXPECTED(generator->execute_data) && EXPECTED(generator->node.parent == NULL)) { generator->flags |= ZEND_GENERATOR_DO_INIT; @@ -837,7 +838,7 @@ static void inline zend_generator_ensure_initialized(zend_generator *generator) } /* }}} */ -static void inline zend_generator_rewind(zend_generator *generator) /* {{{ */ +static inline void zend_generator_rewind(zend_generator *generator) /* {{{ */ { zend_generator_ensure_initialized(generator); @@ -1160,7 +1161,8 @@ static zend_object_iterator_funcs zend_generator_iterator_functions = { zend_generator_iterator_get_data, zend_generator_iterator_get_key, zend_generator_iterator_move_forward, - zend_generator_iterator_rewind + zend_generator_iterator_rewind, + NULL }; zend_object_iterator *zend_generator_get_iterator(zend_class_entry *ce, zval *object, int by_ref) /* {{{ */ diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index a6a89377f7..14f47554d1 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -161,7 +161,7 @@ struct _zend_executor_globals { zend_vm_stack vm_stack; struct _zend_execute_data *current_execute_data; - zend_class_entry *scope; + zend_class_entry *fake_scope; /* used to avoid checks accessing properties */ zend_long precision; @@ -174,8 +174,10 @@ struct _zend_executor_globals { /* for extended information support */ zend_bool no_extensions; -#ifdef ZEND_WIN32 zend_bool timed_out; + zend_long hard_timeout; + +#ifdef ZEND_WIN32 OSVERSIONINFOEX windows_version_info; #endif diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c index 5404187a97..e116ffe55e 100644 --- a/Zend/zend_hash.c +++ b/Zend/zend_hash.c @@ -92,7 +92,7 @@ static void _zend_is_inconsistent(const HashTable *ht, const char *file, int lin static void ZEND_FASTCALL zend_hash_do_resize(HashTable *ht); -static uint32_t zend_always_inline zend_hash_check_size(uint32_t nSize) +static zend_always_inline uint32_t zend_hash_check_size(uint32_t nSize) { #if defined(ZEND_WIN32) unsigned long index; @@ -127,7 +127,7 @@ static uint32_t zend_always_inline zend_hash_check_size(uint32_t nSize) #endif } -static void zend_always_inline zend_hash_real_init_ex(HashTable *ht, int packed) +static zend_always_inline void zend_hash_real_init_ex(HashTable *ht, int packed) { HT_ASSERT(GC_REFCOUNT(ht) == 1); ZEND_ASSERT(!((ht)->u.flags & HASH_FLAG_INITIALIZED)); @@ -139,7 +139,7 @@ static void zend_always_inline zend_hash_real_init_ex(HashTable *ht, int packed) (ht)->nTableMask = -(ht)->nTableSize; HT_SET_DATA_ADDR(ht, pemalloc(HT_SIZE(ht), (ht)->u.flags & HASH_FLAG_PERSISTENT)); (ht)->u.flags |= HASH_FLAG_INITIALIZED; - if (EXPECTED(ht->nTableMask == -8)) { + if (EXPECTED(ht->nTableMask == (uint32_t)-8)) { Bucket *arData = ht->arData; HT_HASH_EX(arData, -8) = -1; @@ -156,7 +156,7 @@ static void zend_always_inline zend_hash_real_init_ex(HashTable *ht, int packed) } } -static void zend_always_inline zend_hash_check_init(HashTable *ht, int packed) +static zend_always_inline void zend_hash_check_init(HashTable *ht, int packed) { HT_ASSERT(GC_REFCOUNT(ht) == 1); if (UNEXPECTED(!((ht)->u.flags & HASH_FLAG_INITIALIZED))) { diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 8e48a3446c..42283f94dc 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -319,10 +319,13 @@ static zend_bool zend_do_perform_implementation_check(const zend_function *fe, c return 0; } +#if 0 + // This introduces BC break described at https://bugs.php.net/bug.php?id=72119 if (proto_arg_info->type_hint && proto_arg_info->allow_null && !fe_arg_info->allow_null) { /* incompatible nullability */ return 0; } +#endif /* by-ref constraints on arguments are invariant */ if (fe_arg_info->pass_by_reference != proto_arg_info->pass_by_reference) { @@ -657,7 +660,8 @@ static void do_inherit_property(zend_property_info *parent_info, zend_string *ke int parent_num = OBJ_PROP_TO_NUM(parent_info->offset); int child_num = OBJ_PROP_TO_NUM(child_info->offset); - zval_ptr_dtor(&(ce->default_properties_table[parent_num])); + /* Don't keep default properties in GC (thry may be freed by opcache) */ + zval_ptr_dtor_nogc(&(ce->default_properties_table[parent_num])); ce->default_properties_table[parent_num] = ce->default_properties_table[child_num]; ZVAL_UNDEF(&ce->default_properties_table[child_num]); child_info->offset = parent_info->offset; diff --git a/Zend/zend_ini_parser.y b/Zend/zend_ini_parser.y index ae04d2b70c..1078259f22 100644 --- a/Zend/zend_ini_parser.y +++ b/Zend/zend_ini_parser.y @@ -132,11 +132,10 @@ static void zend_ini_get_constant(zval *result, zval *name) if (!memchr(Z_STRVAL_P(name), ':', Z_STRLEN_P(name)) && (c = zend_get_constant(Z_STR_P(name))) != 0) { if (Z_TYPE_P(c) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, c); + ZVAL_DUP(&tmp, c); if (Z_OPT_CONSTANT(tmp)) { - zval_update_constant_ex(&tmp, 1, NULL); + zval_update_constant_ex(&tmp, NULL); } - zval_opt_copy_ctor(&tmp); convert_to_string(&tmp); c = &tmp; } diff --git a/Zend/zend_interfaces.c b/Zend/zend_interfaces.c index c7d225704f..2dadb39b17 100644 --- a/Zend/zend_interfaces.c +++ b/Zend/zend_interfaces.c @@ -59,7 +59,6 @@ ZEND_API zval* zend_call_method(zval *object, zend_class_entry *obj_ce, zend_fun if (!fn_proxy && !obj_ce) { /* no interest in caching and no information already present that is * needed later inside zend_call_function. */ - fci.function_table = !object ? EG(function_table) : NULL; result = zend_call_function(&fci, NULL); zval_ptr_dtor(&fci.function_name); } else { diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 53b2f3f50b..4722846ce7 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -245,7 +245,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type <ast> encaps_var encaps_var_offset isset_variables %type <ast> top_statement_list use_declarations const_list inner_statement_list if_stmt %type <ast> alt_if_stmt for_exprs switch_case_list global_var_list static_var_list -%type <ast> echo_expr_list unset_variables catch_list parameter_list class_statement_list +%type <ast> echo_expr_list unset_variables catch_name_list catch_list parameter_list class_statement_list %type <ast> implements_list case_list if_stmt_without_else %type <ast> non_empty_parameter_list argument_list non_empty_argument_list property_list %type <ast> class_const_list class_const_decl name_list trait_adaptations method_body non_empty_for_exprs @@ -456,10 +456,15 @@ statement: catch_list: /* empty */ { $$ = zend_ast_create_list(0, ZEND_AST_CATCH_LIST); } - | catch_list T_CATCH '(' name T_VARIABLE ')' '{' inner_statement_list '}' + | catch_list T_CATCH '(' catch_name_list T_VARIABLE ')' '{' inner_statement_list '}' { $$ = zend_ast_list_add($1, zend_ast_create(ZEND_AST_CATCH, $4, $5, $8)); } ; +catch_name_list: + name { $$ = zend_ast_create_list(1, ZEND_AST_NAME_LIST, $1); } + | catch_name_list '|' name { $$ = zend_ast_list_add($1, $3); } +; + finally_statement: /* empty */ { $$ = NULL; } | T_FINALLY '{' inner_statement_list '}' { $$ = $3; } diff --git a/Zend/zend_language_scanner.h b/Zend/zend_language_scanner.h index f6412b6dee..d76fdc2ac7 100644 --- a/Zend/zend_language_scanner.h +++ b/Zend/zend_language_scanner.h @@ -63,7 +63,6 @@ typedef struct _zend_heredoc_label { } zend_heredoc_label; BEGIN_EXTERN_C() -int zend_compare_file_handles(zend_file_handle *fh1, zend_file_handle *fh2); ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state); ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state); ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename); diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index 9abe3875ef..22e81dc009 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -271,12 +271,24 @@ static void zend_std_call_issetter(zval *object, zval *member, zval *retval) /* static zend_always_inline int zend_verify_property_access(zend_property_info *property_info, zend_class_entry *ce) /* {{{ */ { + zend_class_entry *scope; + if (property_info->flags & ZEND_ACC_PUBLIC) { return 1; } else if (property_info->flags & ZEND_ACC_PRIVATE) { - return (ce == EG(scope) || property_info->ce == EG(scope)); + if (EG(fake_scope)) { + scope = EG(fake_scope); + } else { + scope = zend_get_executed_scope(); + } + return (ce == scope || property_info->ce == scope); } else if (property_info->flags & ZEND_ACC_PROTECTED) { - return zend_check_protected(property_info->ce, EG(scope)); + if (EG(fake_scope)) { + scope = EG(fake_scope); + } else { + scope = zend_get_executed_scope(); + } + return zend_check_protected(property_info->ce, scope); } return 0; } @@ -301,6 +313,7 @@ static zend_always_inline uint32_t zend_get_property_offset(zend_class_entry *ce zval *zv; zend_property_info *property_info = NULL; uint32_t flags; + zend_class_entry *scope; if (cache_slot && EXPECTED(ce == CACHED_PTR_EX(cache_slot))) { return (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -347,10 +360,16 @@ static zend_always_inline uint32_t zend_get_property_offset(zend_class_entry *ce } } - if (EG(scope) != ce - && EG(scope) - && is_derived_class(ce, EG(scope)) - && (zv = zend_hash_find(&EG(scope)->properties_info, member)) != NULL + if (EG(fake_scope)) { + scope = EG(fake_scope); + } else { + scope = zend_get_executed_scope(); + } + + if (scope != ce + && scope + && is_derived_class(ce, scope) + && (zv = zend_hash_find(&scope->properties_info, member)) != NULL && ((zend_property_info*)Z_PTR_P(zv))->flags & ZEND_ACC_PRIVATE) { property_info = (zend_property_info*)Z_PTR_P(zv); if (UNEXPECTED((property_info->flags & ZEND_ACC_STATIC) != 0)) { @@ -383,6 +402,7 @@ ZEND_API zend_property_info *zend_get_property_info(zend_class_entry *ce, zend_s zval *zv; zend_property_info *property_info = NULL; uint32_t flags; + zend_class_entry *scope; if (UNEXPECTED(ZSTR_VAL(member)[0] == '\0')) { if (!silent) { @@ -424,10 +444,16 @@ ZEND_API zend_property_info *zend_get_property_info(zend_class_entry *ce, zend_s } } - if (EG(scope) != ce - && EG(scope) - && is_derived_class(ce, EG(scope)) - && (zv = zend_hash_find(&EG(scope)->properties_info, member)) != NULL + if (EG(fake_scope)) { + scope = EG(fake_scope); + } else { + scope = zend_get_executed_scope(); + } + + if (scope != ce + && scope + && is_derived_class(ce, scope) + && (zv = zend_hash_find(&scope->properties_info, member)) != NULL && ((zend_property_info*)Z_PTR_P(zv))->flags & ZEND_ACC_PRIVATE) { property_info = (zend_property_info*)Z_PTR_P(zv); } else if (UNEXPECTED(property_info == NULL)) { @@ -486,31 +512,60 @@ ZEND_API int zend_check_property_access(zend_object *zobj, zend_string *prop_inf /* }}} */ static void zend_property_guard_dtor(zval *el) /* {{{ */ { - efree_size(Z_PTR_P(el), sizeof(zend_ulong)); + uint32_t *ptr = (uint32_t*)Z_PTR_P(el); + if (EXPECTED(!(((zend_uintptr_t)ptr) & 1))) { + efree_size(ptr, sizeof(uint32_t)); + } } /* }}} */ -static zend_long *zend_get_property_guard(zend_object *zobj, zend_string *member) /* {{{ */ +ZEND_API uint32_t *zend_get_property_guard(zend_object *zobj, zend_string *member) /* {{{ */ { HashTable *guards; - zend_long stub, *guard; + zval *zv; + uint32_t *ptr; ZEND_ASSERT(GC_FLAGS(zobj) & IS_OBJ_USE_GUARDS); - if (GC_FLAGS(zobj) & IS_OBJ_HAS_GUARDS) { - guards = Z_PTR(zobj->properties_table[zobj->ce->default_properties_count]); + zv = zobj->properties_table + zobj->ce->default_properties_count; + if (EXPECTED(Z_TYPE_P(zv) == IS_STRING)) { + zend_string *str = Z_STR_P(zv); + if (EXPECTED(str == member) || + /* hash values are always pred-calculated here */ + (EXPECTED(ZSTR_H(str) == ZSTR_H(member)) && + EXPECTED(ZSTR_LEN(str) == ZSTR_LEN(member)) && + EXPECTED(memcmp(ZSTR_VAL(str), ZSTR_VAL(member), ZSTR_LEN(member)) == 0))) { + return &zv->u2.property_guard; + } else if (EXPECTED(zv->u2.property_guard == 0)) { + zend_string_release(Z_STR_P(zv)); + ZVAL_STR_COPY(zv, member); + return &zv->u2.property_guard; + } else { + ALLOC_HASHTABLE(guards); + zend_hash_init(guards, 8, NULL, zend_property_guard_dtor, 0); + /* mark pointer as "special" using low bit */ + zend_hash_add_new_ptr(guards, member, + (void*)(((zend_uintptr_t)&zv->u2.property_guard) | 1)); + zend_string_release(Z_STR_P(zv)); + ZVAL_ARR(zv, guards); + } + } else if (EXPECTED(Z_TYPE_P(zv) == IS_ARRAY)) { + guards = Z_ARRVAL_P(zv); ZEND_ASSERT(guards != NULL); - if ((guard = (zend_long *)zend_hash_find_ptr(guards, member)) != NULL) { - return guard; + zv = zend_hash_find(guards, member); + if (zv != NULL) { + return (uint32_t*)(((zend_uintptr_t)Z_PTR_P(zv)) & ~1); } } else { - ALLOC_HASHTABLE(guards); - zend_hash_init(guards, 8, NULL, zend_property_guard_dtor, 0); - Z_PTR(zobj->properties_table[zobj->ce->default_properties_count]) = guards; + ZEND_ASSERT(Z_TYPE_P(zv) == IS_UNDEF); GC_FLAGS(zobj) |= IS_OBJ_HAS_GUARDS; - } - - stub = 0; - return (zend_long *)zend_hash_add_mem(guards, member, &stub, sizeof(zend_ulong)); + ZVAL_STR_COPY(zv, member); + zv->u2.property_guard = 0; + return &zv->u2.property_guard; + } + /* we have to allocate uint32_t separately because ht->arData may be reallocated */ + ptr = (uint32_t*)emalloc(sizeof(uint32_t)); + *ptr = 0; + return (uint32_t*)zend_hash_add_new_ptr(guards, member, ptr); } /* }}} */ @@ -555,7 +610,7 @@ zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_ /* magic isset */ if ((type == BP_VAR_IS) && zobj->ce->__isset) { zval tmp_object, tmp_result; - zend_long *guard = zend_get_property_guard(zobj, Z_STR_P(member)); + uint32_t *guard = zend_get_property_guard(zobj, Z_STR_P(member)); if (!((*guard) & IN_ISSET)) { ZVAL_COPY(&tmp_object, object); @@ -579,7 +634,7 @@ zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_ /* magic get */ if (zobj->ce->__get) { - zend_long *guard = zend_get_property_guard(zobj, Z_STR_P(member)); + uint32_t *guard = zend_get_property_guard(zobj, Z_STR_P(member)); if (!((*guard) & IN_GET)) { zval tmp_object; @@ -674,7 +729,7 @@ found: /* magic set */ if (zobj->ce->__set) { - zend_long *guard = zend_get_property_guard(zobj, Z_STR_P(member)); + uint32_t *guard = zend_get_property_guard(zobj, Z_STR_P(member)); if (!((*guard) & IN_SET)) { zval tmp_object; @@ -944,7 +999,7 @@ static void zend_std_unset_property(zval *object, zval *member, void **cache_slo /* magic unset */ if (zobj->ce->__unset) { - zend_long *guard = zend_get_property_guard(zobj, Z_STR_P(member)); + uint32_t *guard = zend_get_property_guard(zobj, Z_STR_P(member)); if (!((*guard) & IN_UNSET)) { zval tmp_object; @@ -995,6 +1050,7 @@ static void zend_std_unset_dimension(zval *object, zval *offset) /* {{{ */ static inline zend_function *zend_check_private_int(zend_function *fbc, zend_class_entry *ce, zend_string *function_name) /* {{{ */ { zval *func; + zend_class_entry *scope; if (!ce) { return 0; @@ -1006,7 +1062,8 @@ static inline zend_function *zend_check_private_int(zend_function *fbc, zend_cla * 2. One of our parent classes are the same as the scope, and it contains * a private function with the same name that has the same scope. */ - if (fbc->common.scope == ce && EG(scope) == ce) { + scope = zend_get_executed_scope(); + if (fbc->common.scope == ce && scope == ce) { /* rule #1 checks out ok, allow the function call */ return fbc; } @@ -1015,11 +1072,11 @@ static inline zend_function *zend_check_private_int(zend_function *fbc, zend_cla /* Check rule #2 */ ce = ce->parent; while (ce) { - if (ce == EG(scope)) { + if (ce == scope) { if ((func = zend_hash_find(&ce->function_table, function_name))) { fbc = Z_FUNC_P(func); if (fbc->common.fn_flags & ZEND_ACC_PRIVATE - && fbc->common.scope == EG(scope)) { + && fbc->common.scope == scope) { return fbc; } } @@ -1122,6 +1179,7 @@ static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_str zval *func; zend_function *fbc; zend_string *lc_method_name; + zend_class_entry *scope = NULL; ALLOCA_FLAG(use_heap); if (EXPECTED(key != NULL)) { @@ -1160,7 +1218,8 @@ static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_str if (zobj->ce->__call) { fbc = zend_get_user_call_function(zobj->ce, method_name); } else { - zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(method_name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = zend_get_executed_scope(); + zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(method_name), scope ? ZSTR_VAL(scope->name) : ""); fbc = NULL; } } @@ -1168,26 +1227,29 @@ static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_str /* Ensure that we haven't overridden a private function and end up calling * the overriding public function... */ - if (EG(scope) && - is_derived_class(fbc->common.scope, EG(scope)) && - fbc->op_array.fn_flags & ZEND_ACC_CHANGED) { - if ((func = zend_hash_find(&EG(scope)->function_table, lc_method_name)) != NULL) { - zend_function *priv_fbc = Z_FUNC_P(func); - if (priv_fbc->common.fn_flags & ZEND_ACC_PRIVATE - && priv_fbc->common.scope == EG(scope)) { - fbc = priv_fbc; + if (fbc->op_array.fn_flags & (ZEND_ACC_CHANGED|ZEND_ACC_PROTECTED)) { + scope = zend_get_executed_scope(); + } + if (fbc->op_array.fn_flags & ZEND_ACC_CHANGED) { + if (scope && is_derived_class(fbc->common.scope, scope)) { + if ((func = zend_hash_find(&scope->function_table, lc_method_name)) != NULL) { + zend_function *priv_fbc = Z_FUNC_P(func); + if (priv_fbc->common.fn_flags & ZEND_ACC_PRIVATE + && priv_fbc->common.scope == scope) { + fbc = priv_fbc; + } } } } - if ((fbc->common.fn_flags & ZEND_ACC_PROTECTED)) { + if (fbc->common.fn_flags & ZEND_ACC_PROTECTED) { /* Ensure that if we're calling a protected function, we're allowed to do so. * If we're not and __call() handler exists, invoke it, otherwise error out. */ - if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), EG(scope)))) { + if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), scope))) { if (zobj->ce->__call) { fbc = zend_get_user_call_function(zobj->ce, method_name); } else { - zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(method_name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(method_name), scope ? ZSTR_VAL(scope->name) : ""); fbc = NULL; } } @@ -1213,6 +1275,7 @@ ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_st char *lc_class_name; zend_string *lc_function_name; zend_object *object; + zend_class_entry *scope; if (EXPECTED(key != NULL)) { lc_function_name = Z_STR_P(key); @@ -1273,25 +1336,27 @@ ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_st /* Ensure that if we're calling a private function, we're allowed to do so. */ - updated_fbc = zend_check_private_int(fbc, EG(scope), lc_function_name); + scope = zend_get_executed_scope(); + updated_fbc = zend_check_private_int(fbc, scope, lc_function_name); if (EXPECTED(updated_fbc != NULL)) { fbc = updated_fbc; } else { if (ce->__callstatic) { fbc = zend_get_user_callstatic_function(ce, function_name); } else { - zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(function_name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(function_name), scope ? ZSTR_VAL(scope->name) : ""); fbc = NULL; } } } else if ((fbc->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ - if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), EG(scope)))) { + scope = zend_get_executed_scope(); + if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), scope))) { if (ce->__callstatic) { fbc = zend_get_user_callstatic_function(ce, function_name); } else { - zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(function_name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(function_name), scope ? ZSTR_VAL(scope->name) : ""); fbc = NULL; } } @@ -1355,6 +1420,7 @@ ZEND_API ZEND_COLD zend_bool zend_std_unset_static_property(zend_class_entry *ce ZEND_API union _zend_function *zend_std_get_constructor(zend_object *zobj) /* {{{ */ { zend_function *constructor = zobj->ce->constructor; + zend_class_entry *scope; if (constructor) { if (constructor->op_array.fn_flags & ZEND_ACC_PUBLIC) { @@ -1362,9 +1428,14 @@ ZEND_API union _zend_function *zend_std_get_constructor(zend_object *zobj) /* {{ } else if (constructor->op_array.fn_flags & ZEND_ACC_PRIVATE) { /* Ensure that if we're calling a private function, we're allowed to do so. */ - if (UNEXPECTED(constructor->common.scope != EG(scope))) { - if (EG(scope)) { - zend_throw_error(NULL, "Call to private %s::%s() from context '%s'", ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name), ZSTR_VAL(EG(scope)->name)); + if (EG(fake_scope)) { + scope = EG(fake_scope); + } else { + scope = zend_get_executed_scope(); + } + if (UNEXPECTED(constructor->common.scope != scope)) { + if (scope) { + zend_throw_error(NULL, "Call to private %s::%s() from context '%s'", ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name), ZSTR_VAL(scope->name)); constructor = NULL; } else { zend_throw_error(NULL, "Call to private %s::%s() from invalid context", ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name)); @@ -1376,9 +1447,14 @@ ZEND_API union _zend_function *zend_std_get_constructor(zend_object *zobj) /* {{ * Constructors only have prototype if they are defined by an interface but * it is the compilers responsibility to take care of the prototype. */ - if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(constructor), EG(scope)))) { - if (EG(scope)) { - zend_throw_error(NULL, "Call to protected %s::%s() from context '%s'", ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name), ZSTR_VAL(EG(scope)->name)); + if (EG(fake_scope)) { + scope = EG(fake_scope); + } else { + scope = zend_get_executed_scope(); + } + if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(constructor), scope))) { + if (scope) { + zend_throw_error(NULL, "Call to protected %s::%s() from context '%s'", ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name), ZSTR_VAL(scope->name)); constructor = NULL; } else { zend_throw_error(NULL, "Call to protected %s::%s() from invalid context", ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name)); @@ -1507,7 +1583,7 @@ found: result = 0; if ((has_set_exists != 2) && zobj->ce->__isset) { - zend_long *guard = zend_get_property_guard(zobj, Z_STR_P(member)); + uint32_t *guard = zend_get_property_guard(zobj, Z_STR_P(member)); if (!((*guard) & IN_ISSET)) { zval rv; diff --git a/Zend/zend_object_handlers.h b/Zend/zend_object_handlers.h index 0b51db6743..2e397093ac 100644 --- a/Zend/zend_object_handlers.h +++ b/Zend/zend_object_handlers.h @@ -27,8 +27,8 @@ struct _zend_property_info; #define ZEND_WRONG_PROPERTY_INFO \ ((struct _zend_property_info*)((zend_intptr_t)-1)) -#define ZEND_DYNAMIC_PROPERTY_OFFSET (-1) -#define ZEND_WRONG_PROPERTY_OFFSET (-2) +#define ZEND_DYNAMIC_PROPERTY_OFFSET ((uint32_t)(-1)) +#define ZEND_WRONG_PROPERTY_OFFSET ((uint32_t)(-2)) /* The following rule applies to read_property() and read_dimension() implementations: If you return a zval which is not otherwise referenced by the extension or the engine's @@ -180,6 +180,8 @@ ZEND_API int zend_check_property_access(zend_object *zobj, zend_string *prop_inf ZEND_API zend_function *zend_get_call_trampoline_func(zend_class_entry *ce, zend_string *method_name, int is_static); +ZEND_API uint32_t *zend_get_property_guard(zend_object *zobj, zend_string *member); + #define zend_free_trampoline(func) do { \ if ((func) == &EG(trampoline)) { \ EG(trampoline).common.function_name = NULL; \ diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c index 793d1ac4c3..53d215d27e 100644 --- a/Zend/zend_objects.c +++ b/Zend/zend_objects.c @@ -46,7 +46,6 @@ ZEND_API void zend_object_std_init(zend_object *object, zend_class_entry *ce) } if (UNEXPECTED(ce->ce_flags & ZEND_ACC_USE_GUARDS)) { GC_FLAGS(object) |= IS_OBJ_USE_GUARDS; - Z_PTR_P(p) = NULL; ZVAL_UNDEF(p); } } @@ -71,11 +70,17 @@ ZEND_API void zend_object_std_dtor(zend_object *object) } while (p != end); } if (UNEXPECTED(GC_FLAGS(object) & IS_OBJ_HAS_GUARDS)) { - HashTable *guards = Z_PTR_P(p); + if (EXPECTED(Z_TYPE_P(p) == IS_STRING)) { + zend_string_release(Z_STR_P(p)); + } else { + HashTable *guards; - ZEND_ASSERT(guards != NULL); - zend_hash_destroy(guards); - FREE_HASHTABLE(guards); + ZEND_ASSERT(Z_TYPE_P(p) == IS_ARRAY); + guards = Z_ARRVAL_P(p); + ZEND_ASSERT(guards != NULL); + zend_hash_destroy(guards); + FREE_HASHTABLE(guards); + } } } @@ -91,39 +96,39 @@ ZEND_API void zend_objects_destroy_object(zend_object *object) if (destructor->op_array.fn_flags & ZEND_ACC_PRIVATE) { /* Ensure that if we're calling a private function, we're allowed to do so. */ - if (object->ce != EG(scope)) { - zend_class_entry *ce = object->ce; + if (EG(current_execute_data)) { + zend_class_entry *scope = zend_get_executed_scope(); - if (EG(current_execute_data)) { + if (object->ce != scope) { zend_throw_error(NULL, "Call to private %s::__destruct() from context '%s'", - ZSTR_VAL(ce->name), - EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); - } else { - zend_error(E_WARNING, - "Call to private %s::__destruct() from context '%s' during shutdown ignored", - ZSTR_VAL(ce->name), - EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + ZSTR_VAL(object->ce->name), + scope ? ZSTR_VAL(scope->name) : ""); + return; } + } else { + zend_error(E_WARNING, + "Call to private %s::__destruct() from context '' during shutdown ignored", + ZSTR_VAL(object->ce->name)); return; } } else { /* Ensure that if we're calling a protected function, we're allowed to do so. */ - if (!zend_check_protected(zend_get_function_root_class(destructor), EG(scope))) { - zend_class_entry *ce = object->ce; + if (EG(current_execute_data)) { + zend_class_entry *scope = zend_get_executed_scope(); - if (EG(current_execute_data)) { + if (!zend_check_protected(zend_get_function_root_class(destructor), scope)) { zend_throw_error(NULL, "Call to protected %s::__destruct() from context '%s'", - ZSTR_VAL(ce->name), - EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); - } else { - zend_error(E_WARNING, - "Call to protected %s::__destruct() from context '%s' during shutdown ignored", - ZSTR_VAL(ce->name), - EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + ZSTR_VAL(object->ce->name), + scope ? ZSTR_VAL(scope->name) : ""); + return; } + } else { + zend_error(E_WARNING, + "Call to protected %s::__destruct() from context '' during shutdown ignored", + ZSTR_VAL(object->ce->name)); return; } } diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 6c1488ad0c..27c04e3a76 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -736,7 +736,7 @@ ZEND_API int pass_two(zend_op_array *op_array) } if (op_array->live_range) { - uint32_t i; + int i; for (i = 0; i < op_array->last_live_range; i++) { op_array->live_range[i].var = diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index 1710ba44dd..e24d033da3 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -136,17 +136,6 @@ ZEND_API zend_long ZEND_FASTCALL zend_atol(const char *str, int str_len) /* {{{ } /* }}} */ -static zend_always_inline void zend_unwrap_reference(zval *op) /* {{{ */ -{ - if (Z_REFCOUNT_P(op) == 1) { - ZVAL_UNREF(op); - } else { - Z_DELREF_P(op); - ZVAL_COPY(op, Z_REFVAL_P(op)); - } -} -/* }}} */ - void ZEND_FASTCALL _convert_scalar_to_number(zval *op, zend_bool silent) /* {{{ */ { try_again: @@ -610,26 +599,26 @@ try_again: if (Z_OBJ_HT_P(op)->get_properties) { HashTable *obj_ht = Z_OBJ_HT_P(op)->get_properties(op); if (obj_ht) { - zval arr; + zend_array *arr; if (!Z_OBJCE_P(op)->default_properties_count && obj_ht == Z_OBJ_P(op)->properties && !ZEND_HASH_GET_APPLY_COUNT(Z_OBJ_P(op)->properties)) { /* fast copy */ if (EXPECTED(Z_OBJ_P(op)->handlers == &std_object_handlers)) { - ZVAL_ARR(&arr, obj_ht); + arr = obj_ht; if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(op)->properties) & IS_ARRAY_IMMUTABLE))) { GC_REFCOUNT(Z_OBJ_P(op)->properties)++; } } else { - ZVAL_ARR(&arr, zend_array_dup(obj_ht)); + arr = zend_array_dup(obj_ht); } zval_dtor(op); - ZVAL_COPY_VALUE(op, &arr); + ZVAL_ARR(op, arr); } else { - ZVAL_ARR(&arr, zend_array_dup(obj_ht)); + arr = zend_array_dup(obj_ht); zval_dtor(op); - ZVAL_COPY_VALUE(op, &arr); + ZVAL_ARR(op, arr); } return; } @@ -747,6 +736,7 @@ static zend_always_inline zend_long ZEND_FASTCALL _zval_get_long_func_ex(zval *o { try_again: switch (Z_TYPE_P(op)) { + case IS_UNDEF: case IS_NULL: case IS_FALSE: return 0; @@ -2942,6 +2932,8 @@ static zend_always_inline void zend_memnstr_ex_pre(unsigned int td[], const char td[(unsigned char)needle[i]] = i + 1; } } else { + size_t i; + for (i = 0; i < needle_len; i++) { td[(unsigned char)needle[i]] = (int)needle_len - i; } diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h index db6162a4e5..405ca0926f 100644 --- a/Zend/zend_operators.h +++ b/Zend/zend_operators.h @@ -821,6 +821,18 @@ static zend_always_inline char *zend_print_long_to_buf(char *buf, zend_long num) ZEND_API zend_string* ZEND_FASTCALL zend_long_to_str(zend_long num); +static zend_always_inline void zend_unwrap_reference(zval *op) /* {{{ */ +{ + if (Z_REFCOUNT_P(op) == 1) { + ZVAL_UNREF(op); + } else { + Z_DELREF_P(op); + ZVAL_COPY(op, Z_REFVAL_P(op)); + } +} +/* }}} */ + + END_EXTERN_C() #endif diff --git a/Zend/zend_types.h b/Zend/zend_types.h index 5207386ccf..45c2ebdf70 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -131,7 +131,6 @@ struct _zval_struct { uint32_t type_info; } u1; union { - uint32_t var_flags; uint32_t next; /* hash collision chain */ uint32_t cache_slot; /* literal cache slot */ uint32_t lineno; /* line number (for ast nodes) */ @@ -139,6 +138,7 @@ struct _zval_struct { uint32_t fe_pos; /* foreach position */ uint32_t fe_iter_idx; /* foreach iterator index */ uint32_t access_flags; /* class constant access flags */ + uint32_t property_guard; /* single property guard */ } u2; }; @@ -345,9 +345,6 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) { #define Z_CONST_FLAGS(zval) (zval).u1.v.const_flags #define Z_CONST_FLAGS_P(zval_p) Z_CONST_FLAGS(*(zval_p)) -#define Z_VAR_FLAGS(zval) (zval).u2.var_flags -#define Z_VAR_FLAGS_P(zval_p) Z_VAR_FLAGS(*(zval_p)) - #define Z_TYPE_INFO(zval) (zval).u1.type_info #define Z_TYPE_INFO_P(zval_p) Z_TYPE_INFO(*(zval_p)) @@ -413,11 +410,13 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) { /* zval.u1.v.const_flags */ #define IS_CONSTANT_UNQUALIFIED 0x010 +#define IS_CONSTANT_VISITED_MARK 0x020 #define IS_CONSTANT_CLASS 0x080 /* __CLASS__ in trait */ #define IS_CONSTANT_IN_NAMESPACE 0x100 /* used only in opline->extended_value */ -/* zval.u2.var_flags */ -#define IS_VAR_RET_REF (1<<0) /* return by by reference */ +#define IS_CONSTANT_VISITED(p) (Z_CONST_FLAGS_P(p) & IS_CONSTANT_VISITED_MARK) +#define MARK_CONSTANT_VISITED(p) Z_CONST_FLAGS_P(p) |= IS_CONSTANT_VISITED_MARK +#define RESET_CONSTANT_VISITED(p) Z_CONST_FLAGS_P(p) &= ~IS_CONSTANT_VISITED_MARK /* string flags (zval.value->gc.u.flags) */ #define IS_STR_PERSISTENT (1<<0) /* allocated using malloc */ @@ -929,7 +928,7 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) { #define SEPARATE_ARRAY(zv) do { \ zval *_zv = (zv); \ zend_array *_arr = Z_ARR_P(_zv); \ - if (GC_REFCOUNT(_arr) > 1) { \ + if (UNEXPECTED(GC_REFCOUNT(_arr) > 1)) { \ if (!Z_IMMUTABLE_P(_zv)) { \ GC_REFCOUNT(_arr)--; \ } \ diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c index 056cc72dae..01b68c25a4 100644 --- a/Zend/zend_variables.c +++ b/Zend/zend_variables.c @@ -30,17 +30,20 @@ ZEND_API void ZEND_FASTCALL _zval_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC) { + if (--GC_REFCOUNT(p)) { + return; + } + switch (GC_TYPE(p)) { case IS_STRING: case IS_CONSTANT: { zend_string *str = (zend_string*)p; CHECK_ZVAL_STRING_REL(str); - zend_string_release(str); + zend_string_free(str); break; } case IS_ARRAY: { zend_array *arr = (zend_array*)p; - ZEND_ASSERT(GC_REFCOUNT(arr) <= 1); zend_array_destroy(arr); break; } @@ -54,25 +57,21 @@ ZEND_API void ZEND_FASTCALL _zval_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC case IS_OBJECT: { zend_object *obj = (zend_object*)p; - OBJ_RELEASE(obj); + zend_objects_store_del(obj); break; } case IS_RESOURCE: { zend_resource *res = (zend_resource*)p; - if (--GC_REFCOUNT(res) == 0) { - /* destroy resource */ - zend_list_free(res); - } + /* destroy resource */ + zend_list_free(res); break; } case IS_REFERENCE: { zend_reference *ref = (zend_reference*)p; - if (--GC_REFCOUNT(ref) == 0) { - i_zval_ptr_dtor(&ref->val ZEND_FILE_LINE_RELAY_CC); - efree_size(ref, sizeof(zend_reference)); - } + i_zval_ptr_dtor(&ref->val ZEND_FILE_LINE_RELAY_CC); + efree_size(ref, sizeof(zend_reference)); break; } default: @@ -225,12 +224,8 @@ ZEND_API void ZEND_FASTCALL _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC) CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue)); Z_STR_P(zvalue) = zend_string_dup(Z_STR_P(zvalue), 0); } else if (EXPECTED(Z_TYPE_P(zvalue) == IS_CONSTANT_AST)) { - zend_ast_ref *ast = emalloc(sizeof(zend_ast_ref)); - - GC_REFCOUNT(ast) = 1; - GC_TYPE_INFO(ast) = IS_CONSTANT_AST; - ast->ast = zend_ast_copy(Z_ASTVAL_P(zvalue)); - Z_AST_P(zvalue) = ast; + zend_ast *copy = zend_ast_copy(Z_ASTVAL_P(zvalue)); + ZVAL_NEW_AST(zvalue, copy); } } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 7a6974de09..afd0b1a398 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -766,11 +766,11 @@ ZEND_VM_HELPER(zend_binary_assign_op_dim_helper, VAR|UNUSED|CV, CONST|TMPVAR|UNU { USE_OPLINE zend_free_op free_op1, free_op2, free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); - container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW); + container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); @@ -778,40 +778,87 @@ ZEND_VM_HELPER(zend_binary_assign_op_dim_helper, VAR|UNUSED|CV, CONST|TMPVAR|UNU HANDLE_EXCEPTION(); } - dim = GET_OP2_ZVAL_PTR(BP_VAR_R); + if (OP1_TYPE != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +ZEND_VM_C_LABEL(assign_dim_op_array): + SEPARATE_ARRAY(container); +ZEND_VM_C_LABEL(assign_dim_op_new_array): + if (OP2_TYPE == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + ZEND_VM_C_GOTO(assign_dim_op_ret_null); + } + } else { + dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R); - do { - if (OP1_TYPE == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (OP1_TYPE != IS_UNUSED) { - ZVAL_DEREF(container); + if (OP2_TYPE == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (OP1_TYPE == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + ZEND_VM_C_GOTO(assign_dim_op_ret_null); } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, OP2_TYPE); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (OP1_TYPE != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + ZEND_VM_C_GOTO(assign_dim_op_array); + } + } else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + ZEND_VM_C_GOTO(assign_dim_op_convert_to_array); } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = GET_OP2_ZVAL_PTR(BP_VAR_R); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (OP1_TYPE == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (OP1_TYPE != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +ZEND_VM_C_LABEL(assign_dim_op_convert_to_array): + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + ZEND_VM_C_GOTO(assign_dim_op_new_array); + } + + if (OP2_TYPE == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + ZEND_VM_C_GOTO(assign_dim_op_convert_to_array); + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +ZEND_VM_C_LABEL(assign_dim_op_ret_null): + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } FREE_OP2(); FREE_OP(free_op_data1); @@ -1690,8 +1737,8 @@ ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMPVAR|CV, CONST|TMPVAR|CV) zval *container; SAVE_OPLINE(); - container = GET_OP1_ZVAL_PTR(BP_VAR_R); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE); + container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE); FREE_OP2(); FREE_OP1(); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -1706,7 +1753,7 @@ ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV) SAVE_OPLINE(); container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W); - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE); FREE_OP2(); if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -1722,9 +1769,9 @@ ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV) zval *container; SAVE_OPLINE(); - container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW); + container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); - zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE); FREE_OP2(); if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -1740,8 +1787,8 @@ ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, CONST|TMPVAR|CV, CONST|TMPVAR|CV) zval *container; SAVE_OPLINE(); - container = GET_OP1_ZVAL_PTR(BP_VAR_IS); - zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE); + container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_IS); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE); FREE_OP2(); FREE_OP1(); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -1763,7 +1810,7 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUS HANDLE_EXCEPTION(); } container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W); - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE); if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } @@ -1776,8 +1823,8 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUS FREE_UNFETCHED_OP1(); HANDLE_EXCEPTION(); } - container = GET_OP1_ZVAL_PTR(BP_VAR_R); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE); + container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE); FREE_OP2(); FREE_OP1(); } @@ -1791,9 +1838,9 @@ ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMPVAR|CV) zval *container; SAVE_OPLINE(); - container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_UNSET); + container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_UNSET); - zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE); FREE_OP2(); if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -2065,94 +2112,12 @@ ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV) ZEND_VM_HANDLER(98, ZEND_FETCH_LIST, CONST|TMPVAR|CV, CONST|TMPVAR|CV) { USE_OPLINE - zend_free_op free_op1; - zend_free_op free_op2; + zend_free_op free_op1, free_op2; zval *container; - zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R); SAVE_OPLINE(); container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); - -ZEND_VM_C_LABEL(try_fetch_list): - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value; - zend_string *str; - zend_ulong hval; - -ZEND_VM_C_LABEL(assign_again_list): - if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -ZEND_VM_C_LABEL(num_index_list): - value = zend_hash_index_find(Z_ARRVAL_P(container), hval); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined offset: " ZEND_ULONG_FMT, hval); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - - if (ZEND_HANDLE_NUMERIC(str, hval)) { - ZEND_VM_C_GOTO(num_index_list); - } - -ZEND_VM_C_LABEL(str_index_list): - value = zend_hash_find(Z_ARRVAL_P(container), str); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(str)); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (UNEXPECTED(str != Z_STR_P(offset))) { - zend_string_release(str); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - ZEND_VM_C_GOTO(assign_again_list); - } else if (Z_TYPE_P(offset) == IS_NULL) { - str = ZSTR_EMPTY_ALLOC(); - ZEND_VM_C_GOTO(str_index_list); - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - ZEND_VM_C_GOTO(num_index_list); - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - ZEND_VM_C_GOTO(num_index_list); - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - ZEND_VM_C_GOTO(num_index_list); - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(offset), Z_RES_HANDLE_P(offset)); - hval = Z_RES_HANDLE_P(offset); - } else { - zend_error(E_WARNING, "Illegal offset type"); - } - } else if (OP1_TYPE != IS_CONST && - UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && - EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { - zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, offset, BP_VAR_R, result); - - if (retval) { - if (result != retval) { - ZVAL_COPY(result, retval); - } - } else { - ZVAL_NULL(result); - } - } else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) { - container = Z_REFVAL_P(container); - ZEND_VM_C_GOTO(try_fetch_list); - } else { - if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - GET_OP1_UNDEF_CV(container, BP_VAR_R); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - } + zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R)); FREE_OP2(); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -2343,31 +2308,29 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV, SPEC( if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { ZEND_VM_C_LABEL(try_assign_dim_array): + SEPARATE_ARRAY(object_ptr); 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 = NULL; + ZEND_VM_C_GOTO(assign_dim_error); } } 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(); - } - if (UNEXPECTED(variable_ptr == NULL)) { - FREE_UNFETCHED_OP_DATA(); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R); + if (OP2_TYPE == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R); - value = zend_assign_to_variable(variable_ptr, value, OP_DATA_TYPE); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + ZEND_VM_C_GOTO(assign_dim_error); } } + value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R); + value = zend_assign_to_variable(variable_ptr, value, OP_DATA_TYPE); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -2376,11 +2339,24 @@ ZEND_VM_C_LABEL(try_assign_dim_array): } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_free_op free_op2; - zval *property_name = GET_OP2_ZVAL_PTR(BP_VAR_R); + dim = GET_OP2_ZVAL_PTR(BP_VAR_R); + value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, OP_DATA_TYPE, (opline+1)->op1, execute_data); - FREE_OP2(); + if (OP_DATA_TYPE == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (OP_DATA_TYPE == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + FREE_OP_DATA(); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (OP2_TYPE == IS_UNUSED) { @@ -2389,13 +2365,9 @@ ZEND_VM_C_LABEL(try_assign_dim_array): FREE_OP1_VAR_PTR(); HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = GET_OP2_ZVAL_PTR(BP_VAR_R); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - FREE_OP2(); value = GET_OP_DATA_ZVAL_PTR_DEREF(BP_VAR_R); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); FREE_OP_DATA(); } } else { @@ -2407,18 +2379,21 @@ ZEND_VM_C_LABEL(assign_dim_convert_to_array): } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { ZEND_VM_C_GOTO(assign_dim_convert_to_array); - } else if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - ZEND_VM_C_GOTO(assign_dim_clean); } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -ZEND_VM_C_LABEL(assign_dim_clean): - FREE_UNFETCHED_OP2(); + if (OP1_TYPE != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = GET_OP2_ZVAL_PTR(BP_VAR_R); +ZEND_VM_C_LABEL(assign_dim_error): FREE_UNFETCHED_OP_DATA(); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (OP2_TYPE != IS_UNUSED) { + FREE_OP2(); + } FREE_OP1_VAR_PTR(); /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -2474,8 +2449,7 @@ ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC) } else if (OP2_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_FUNCTION && - UNEXPECTED(!(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { - + UNEXPECTED(!Z_ISREF_P(value_ptr))) { zend_error(E_NOTICE, "Only variables should be assigned by reference"); if (UNEXPECTED(EG(exception) != NULL)) { FREE_OP2_VAR_PTR(); @@ -2514,34 +2488,54 @@ ZEND_VM_HELPER(zend_leave_helper, ANY, ANY) uint32_t call_info = EX_CALL_INFO(); if (EXPECTED(ZEND_CALL_KIND_EX(call_info) == ZEND_CALL_NESTED_FUNCTION)) { - zend_object *object; - i_free_compiled_variables(execute_data); - if (UNEXPECTED(call_info & ZEND_CALL_FREE_SYMBOL_TABLE)) { - zend_clean_and_cache_symbol_table(EX(symbol_table)); - } - zend_vm_stack_free_extra_args_ex(call_info, execute_data); - old_execute_data = execute_data; - execute_data = EG(current_execute_data) = EX(prev_execute_data); - if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) { - object = Z_OBJ(old_execute_data->This); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED))) { + if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) { + zend_clean_and_cache_symbol_table(EX(symbol_table)); + } + EG(current_execute_data) = EX(prev_execute_data); + if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) { + zend_object *object = Z_OBJ(execute_data->This); #if 0 - if (UNEXPECTED(EG(exception) != NULL) && (EX(opline)->op1.num & ZEND_CALL_CTOR)) { + if (UNEXPECTED(EG(exception) != NULL) && (EX(opline)->op1.num & ZEND_CALL_CTOR)) { #else - if (UNEXPECTED(EG(exception) != NULL) && (call_info & ZEND_CALL_CTOR)) { + if (UNEXPECTED(EG(exception) != NULL) && (call_info & ZEND_CALL_CTOR)) { #endif - GC_REFCOUNT(object)--; - if (GC_REFCOUNT(object) == 1) { - zend_object_store_ctor_failed(object); + GC_REFCOUNT(object)--; + if (GC_REFCOUNT(object) == 1) { + zend_object_store_ctor_failed(object); + } } + OBJ_RELEASE(object); + } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { + OBJ_RELEASE((zend_object*)execute_data->func->op_array.prototype); } - OBJ_RELEASE(object); - } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { - OBJ_RELEASE((zend_object*)old_execute_data->func->op_array.prototype); - } - EG(scope) = EX(func)->op_array.scope; - zend_vm_stack_free_call_frame_ex(call_info, old_execute_data); + zend_vm_stack_free_extra_args_ex(call_info, execute_data); + old_execute_data = execute_data; + execute_data = EX(prev_execute_data); + zend_vm_stack_free_call_frame_ex(call_info, old_execute_data); + } else { + EG(current_execute_data) = EX(prev_execute_data); + if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) { + zend_object *object = Z_OBJ(execute_data->This); +#if 0 + if (UNEXPECTED(EG(exception) != NULL) && (EX(opline)->op1.num & ZEND_CALL_CTOR)) { +#else + if (UNEXPECTED(EG(exception) != NULL) && (call_info & ZEND_CALL_CTOR)) { +#endif + GC_REFCOUNT(object)--; + if (GC_REFCOUNT(object) == 1) { + zend_object_store_ctor_failed(object); + } + } + OBJ_RELEASE(object); + } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { + OBJ_RELEASE((zend_object*)execute_data->func->op_array.prototype); + } + EG(vm_stack_top) = (zval*)execute_data; + execute_data = EX(prev_execute_data); + } if (UNEXPECTED(EG(exception) != NULL)) { const zend_op *old_opline = EX(opline); @@ -2554,8 +2548,7 @@ ZEND_VM_HELPER(zend_leave_helper, ANY, ANY) LOAD_NEXT_OPLINE(); ZEND_VM_LEAVE(); - } - if (EXPECTED((ZEND_CALL_KIND_EX(call_info) & ZEND_CALL_TOP) == 0)) { + } else if (EXPECTED((ZEND_CALL_KIND_EX(call_info) & ZEND_CALL_TOP) == 0)) { zend_detach_symbol_table(execute_data); destroy_op_array(&EX(func)->op_array); efree_size(EX(func), sizeof(zend_op_array)); @@ -2574,21 +2567,24 @@ ZEND_VM_HELPER(zend_leave_helper, ANY, ANY) } else { if (ZEND_CALL_KIND_EX(call_info) == ZEND_CALL_TOP_FUNCTION) { i_free_compiled_variables(execute_data); - if (UNEXPECTED(call_info & ZEND_CALL_FREE_SYMBOL_TABLE)) { - zend_clean_and_cache_symbol_table(EX(symbol_table)); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS))) { + if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) { + zend_clean_and_cache_symbol_table(EX(symbol_table)); + } + zend_vm_stack_free_extra_args_ex(call_info, execute_data); } - zend_vm_stack_free_extra_args_ex(call_info, execute_data); EG(current_execute_data) = EX(prev_execute_data); if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { OBJ_RELEASE((zend_object*)EX(func)->op_array.prototype); } + ZEND_VM_RETURN(); } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ { zend_array *symbol_table = EX(symbol_table); zend_detach_symbol_table(execute_data); old_execute_data = EX(prev_execute_data); while (old_execute_data) { - if (old_execute_data->func && ZEND_USER_CODE(old_execute_data->func->op_array.type)) { + if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) { if (old_execute_data->symbol_table == symbol_table) { zend_attach_symbol_table(old_execute_data); } @@ -2597,9 +2593,8 @@ ZEND_VM_HELPER(zend_leave_helper, ANY, ANY) old_execute_data = old_execute_data->prev_execute_data; } EG(current_execute_data) = EX(prev_execute_data); + ZEND_VM_RETURN(); } - - ZEND_VM_RETURN(); } } @@ -3367,195 +3362,21 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM) ZEND_VM_HANDLER(128, ZEND_INIT_DYNAMIC_CALL, ANY, CONST|TMPVAR|CV, NUM) { 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; + zval *function_name; zend_execute_data *call; - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION; SAVE_OPLINE(); function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R); ZEND_VM_C_LABEL(try_function_name): if (OP2_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - const char *colon; - - if ((colon = zend_memrchr(Z_STRVAL_P(function_name), ':', Z_STRLEN_P(function_name))) != NULL && - colon > Z_STRVAL_P(function_name) && - *(colon-1) == ':' - ) { - zend_string *mname; - size_t cname_length = colon - Z_STRVAL_P(function_name) - 1; - size_t mname_length = Z_STRLEN_P(function_name) - cname_length - (sizeof("::") - 1); - - lcname = zend_string_init(Z_STRVAL_P(function_name), cname_length, 0); - - object = NULL; - called_scope = zend_fetch_class_by_name(lcname, NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(called_scope == NULL)) { - zend_string_release(lcname); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - mname = zend_string_init(Z_STRVAL_P(function_name) + (cname_length + sizeof("::") - 1), mname_length, 0); - - if (called_scope->get_static_method) { - fbc = called_scope->get_static_method(called_scope, mname); - } else { - fbc = zend_std_get_static_method(called_scope, mname, NULL); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), ZSTR_VAL(mname)); - } - zend_string_release(lcname); - zend_string_release(mname); - FREE_OP2(); - HANDLE_EXCEPTION(); - } - - zend_string_release(lcname); - zend_string_release(mname); - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - FREE_OP2(); - HANDLE_EXCEPTION(); - } - } - } else { - if (Z_STRVAL_P(function_name)[0] == '\\') { - lcname = zend_string_alloc(Z_STRLEN_P(function_name) - 1, 0); - zend_str_tolower_copy(ZSTR_VAL(lcname), 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)) { - zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name)); - zend_string_release(lcname); - FREE_OP2(); - HANDLE_EXCEPTION(); - } - zend_string_release(lcname); - - fbc = Z_FUNC_P(func); - called_scope = NULL; - object = NULL; - } - FREE_OP2(); - } 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 (fbc->common.fn_flags & ZEND_ACC_CLOSURE) { - /* Delay closure destruction until its invocation */ - ZEND_ASSERT(GC_TYPE((zend_object*)fbc->common.prototype) == IS_OBJECT); - GC_REFCOUNT((zend_object*)fbc->common.prototype)++; - call_info |= ZEND_CALL_CLOSURE; - } else if (object) { - call_info |= ZEND_CALL_RELEASE_THIS; - GC_REFCOUNT(object)++; /* For $this pointer */ - } - FREE_OP2(); - } 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); - - if (!obj || !method) { - zend_throw_error(NULL, "Array callback has to contain indices 0 and 1"); - FREE_OP2(); - HANDLE_EXCEPTION(); - } - - ZVAL_DEREF(obj); - if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) { - zend_throw_error(NULL, "First array member is not a valid class name or object"); - FREE_OP2(); - HANDLE_EXCEPTION(); - } - - ZVAL_DEREF(method); - if (Z_TYPE_P(method) != IS_STRING) { - zend_throw_error(NULL, "Second array member is not a valid method"); - FREE_OP2(); - HANDLE_EXCEPTION(); - } - - if (Z_TYPE_P(obj) == IS_STRING) { - object = NULL; - called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(called_scope == NULL)) { - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - 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); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), Z_STRVAL_P(method)); - } - FREE_OP2(); - HANDLE_EXCEPTION(); - } - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - FREE_OP2(); - HANDLE_EXCEPTION(); - } - } - } else { - 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)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(object->ce->name), Z_STRVAL_P(method)); - } - FREE_OP2(); - HANDLE_EXCEPTION(); - } - - if ((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { - object = NULL; - } else { - call_info |= ZEND_CALL_RELEASE_THIS; - GC_REFCOUNT(object)++; /* For $this pointer */ - } - } - FREE_OP2(); - } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(function_name) == IS_REFERENCE) { + call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value); + } else if (OP2_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) { + call = zend_init_dynamic_call_object(function_name, opline->extended_value); + } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) { + call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value); + } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) { function_name = Z_REFVAL_P(function_name); ZEND_VM_C_GOTO(try_function_name); } else { @@ -3566,14 +3387,15 @@ ZEND_VM_C_LABEL(try_function_name): } } zend_throw_error(NULL, "Function name must be a string"); - FREE_OP2(); - HANDLE_EXCEPTION(); + call = NULL; } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) { - init_func_run_time_cache(&fbc->op_array); + + FREE_OP2(); + + if (UNEXPECTED(!call)) { + HANDLE_EXCEPTION(); } - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, called_scope, object); + call->prev_execute_data = EX(call); EX(call) = call; @@ -3726,7 +3548,6 @@ ZEND_VM_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL)) ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); - Z_VAR_FLAGS_P(ret) = 0; fbc->internal_function.handler(call, ret); @@ -3735,6 +3556,7 @@ ZEND_VM_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL)) EG(exception) || !call->func || !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT(!Z_ISREF_P(ret)); #endif EG(current_execute_data) = call->prev_execute_data; @@ -3753,8 +3575,8 @@ ZEND_VM_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL)) HANDLE_EXCEPTION(); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } ZEND_VM_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL)) @@ -3767,13 +3589,10 @@ ZEND_VM_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL)) 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; @@ -3793,12 +3612,10 @@ ZEND_VM_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) 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 (EXPECTED(RETURN_VALUE_USED(opline))) { ret = EX_VAR(opline->result.var); zend_generator_create_zval(call, &fbc->op_array, ret); - Z_VAR_FLAGS_P(ret) = 0; } else { zend_vm_stack_free_args(call); } @@ -3806,11 +3623,9 @@ ZEND_VM_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) 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; @@ -3818,7 +3633,6 @@ ZEND_VM_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) ZEND_VM_ENTER(); } - EG(scope) = EX(func)->op_array.scope; } else { zval retval; ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); @@ -3836,34 +3650,25 @@ ZEND_VM_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) call->prev_execute_data = execute_data; EG(current_execute_data) = call; - 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); - - for (i = 0; i < num_args; ++i) { - if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) { - 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(); - } - p++; - } + if (UNEXPECTED(fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) + && UNEXPECTED(!zend_verify_internal_arg_types(fbc, call))) { + zend_vm_stack_free_call_frame(call); + zend_throw_exception_internal(NULL); + HANDLE_EXCEPTION(); } ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; 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); #if ZEND_DEBUG - ZEND_ASSERT( - EG(exception) || !call->func || - !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || - zend_verify_internal_return_type(call->func, ret)); + if (!EG(exception) && call->func) { + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } #endif EG(current_execute_data) = call->prev_execute_data; @@ -3882,8 +3687,8 @@ ZEND_VM_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) } HANDLE_EXCEPTION(); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) @@ -3915,12 +3720,10 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) LOAD_OPLINE(); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { - EG(scope) = fbc->common.scope; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_GENERATOR) != 0)) { if (EXPECTED(RETURN_VALUE_USED(opline))) { ret = EX_VAR(opline->result.var); zend_generator_create_zval(call, &fbc->op_array, ret); - Z_VAR_FLAGS_P(ret) = 0; } else { if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) { OBJ_RELEASE((zend_object*)fbc->op_array.prototype); @@ -3929,11 +3732,9 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) } } 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; @@ -3947,42 +3748,21 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) } } } else if (EXPECTED(fbc->type < ZEND_USER_FUNCTION)) { - int should_change_scope = 0; zval retval; - if (fbc->common.scope) { - should_change_scope = 1; - EG(scope) = fbc->common.scope; - } - call->prev_execute_data = execute_data; EG(current_execute_data) = call; - 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); - - for (i = 0; i < num_args; ++i) { - if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) { - EG(current_execute_data) = call->prev_execute_data; - zend_vm_stack_free_args(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); - } - } - p++; + if (UNEXPECTED(fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) + && UNEXPECTED(!zend_verify_internal_arg_types(fbc, call))) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); } + ZEND_VM_C_GOTO(fcall_end); } ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; 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 */ @@ -3992,10 +3772,12 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) } #if ZEND_DEBUG - ZEND_ASSERT( - EG(exception) || !call->func || - !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || - zend_verify_internal_return_type(call->func, ret)); + if (!EG(exception) && call->func) { + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } #endif EG(current_execute_data) = call->prev_execute_data; @@ -4005,52 +3787,23 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) zval_ptr_dtor(ret); } - if (UNEXPECTED(should_change_scope)) { - ZEND_VM_C_GOTO(fcall_end_change_scope); - } else { - ZEND_VM_C_GOTO(fcall_end); - } } else { /* ZEND_OVERLOADED_FUNCTION */ zval retval; - /* Not sure what should be done here if it's a static method */ - if (UNEXPECTED(Z_TYPE(call->This) != IS_OBJECT)) { - zend_vm_stack_free_args(call); - if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { - zend_string_release(fbc->common.function_name); - } - efree(fbc); - zend_vm_stack_free_call_frame(call); - - zend_throw_error(NULL, "Cannot call overloaded function for non-object"); - HANDLE_EXCEPTION(); - } - - object = Z_OBJ(call->This); - EG(scope) = fbc->common.scope; ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; - ZVAL_NULL(ret); call->prev_execute_data = execute_data; - EG(current_execute_data) = call; - object->handlers->call_method(fbc->common.function_name, object, call, ret); - EG(current_execute_data) = call->prev_execute_data; - - zend_vm_stack_free_args(call); - if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { - zend_string_release(fbc->common.function_name); + if (UNEXPECTED(!zend_do_fcall_overloaded(fbc, call, ret))) { + HANDLE_EXCEPTION(); } - efree(fbc); if (!RETURN_VALUE_USED(opline)) { zval_ptr_dtor(ret); - } else { - Z_VAR_FLAGS_P(ret) = 0; } } -ZEND_VM_C_LABEL(fcall_end_change_scope): +ZEND_VM_C_LABEL(fcall_end): if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) { object = Z_OBJ(call->This); #if 0 @@ -4065,9 +3818,7 @@ ZEND_VM_C_LABEL(fcall_end_change_scope): } OBJ_RELEASE(object); } - EG(scope) = EX(func)->op_array.scope; -ZEND_VM_C_LABEL(fcall_end): zend_vm_stack_free_call_frame(call); if (UNEXPECTED(EG(exception) != NULL)) { zend_throw_exception_internal(NULL); @@ -4077,8 +3828,8 @@ ZEND_VM_C_LABEL(fcall_end): HANDLE_EXCEPTION(); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } ZEND_VM_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED) @@ -4217,14 +3968,16 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC) retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R); if (!EX(return_value)) { - if (OP1_TYPE == IS_TMP_VAR) { - FREE_OP1(); - } + FREE_OP1(); } else { - ZVAL_COPY_VALUE(EX(return_value), retval_ptr); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; - if (OP1_TYPE != IS_TMP_VAR) { - zval_opt_copy_ctor_no_imm(EX(return_value)); + if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); + break; + } + + ZVAL_NEW_REF(EX(return_value), retval_ptr); + if (OP1_TYPE == IS_CONST) { + if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); } } break; @@ -4234,13 +3987,12 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC) 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))) { + (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr))) { zend_error(E_NOTICE, "Only variable references should be returned by reference"); if (EX(return_value)) { ZVAL_NEW_REF(EX(return_value), retval_ptr); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; - if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); + } else { + FREE_OP1_VAR_PTR(); } break; } @@ -4250,11 +4002,11 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC) ZVAL_MAKE_REF(retval_ptr); Z_ADDREF_P(retval_ptr); ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr)); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; } + + FREE_OP1_VAR_PTR(); } while (0); - FREE_OP1_VAR_PTR(); ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } @@ -4494,27 +4246,24 @@ ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR, NUM, SEND) varptr = GET_OP1_ZVAL_PTR(BP_VAR_R); - if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) || - (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) && - (Z_ISREF_P(varptr) || Z_TYPE_P(varptr) == IS_OBJECT)) { + if (EXPECTED(Z_ISREF_P(varptr) || + ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ? + ((opline->extended_value & ZEND_ARG_SEND_SILENT) != 0) : + ARG_MAY_BE_SENT_BY_REF(EX(call)->func, opline->op2.num + )))) { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_COPY_VALUE(arg, varptr); - ZVAL_MAKE_REF(varptr); - } else { - if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ? - !(opline->extended_value & ZEND_ARG_SEND_SILENT) : - !ARG_MAY_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) { - SAVE_OPLINE(); - zend_error(E_NOTICE, "Only variables should be passed by reference"); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, varptr); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } + ZEND_VM_NEXT_OPCODE(); } + SAVE_OPLINE(); + zend_error(E_NOTICE, "Only variables should be passed by reference"); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); ZVAL_COPY_VALUE(arg, varptr); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, NUM) @@ -4613,7 +4362,7 @@ ZEND_VM_C_LABEL(send_again): zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht)); - if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_TMP_VAR && Z_IMMUTABLE_P(args)) { + if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) { uint32_t i; int separate = 0; @@ -4625,7 +4374,7 @@ ZEND_VM_C_LABEL(send_again): } } if (separate) { - zval_copy_ctor(args); + SEPARATE_ARRAY(args); ht = Z_ARRVAL_P(args); } } @@ -4639,7 +4388,7 @@ ZEND_VM_C_LABEL(send_again): top = ZEND_CALL_ARG(EX(call), arg_num); if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - if (!Z_IMMUTABLE_P(args)) { + if (Z_REFCOUNT_P(args) == 1) { ZVAL_MAKE_REF(arg); Z_ADDREF_P(arg); ZVAL_REF(top, Z_REF_P(arg)); @@ -4781,7 +4530,7 @@ ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY) } EX(call)->func = (zend_function*)&zend_pass_function; Z_OBJ(EX(call)->This) = NULL; - ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call))); + ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call)) & ~ZEND_CALL_RELEASE_THIS); } else { uint32_t arg_num; HashTable *ht; @@ -4791,22 +4540,6 @@ ZEND_VM_C_LABEL(send_array): ht = Z_ARRVAL_P(args); zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht)); - 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 */ - for (arg_num = 0; arg_num < zend_hash_num_elements(ht); arg_num++) { - if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num + 1)) { - separate = 1; - break; - } - } - if (separate) { - zval_copy_ctor(args); - ht = Z_ARRVAL_P(args); - } - } - arg_num = 1; param = ZEND_CALL_ARG(EX(call), 1); ZEND_HASH_FOREACH_VAL(ht, arg) { @@ -4828,25 +4561,18 @@ ZEND_VM_C_LABEL(send_array): } EX(call)->func = (zend_function*)&zend_pass_function; Z_OBJ(EX(call)->This) = NULL; - ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call))); - + ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call)) & ~ZEND_CALL_RELEASE_THIS); break; } - - ZVAL_NEW_REF(arg, arg); } - Z_ADDREF_P(arg); - } else{ + } else { if (Z_ISREF_P(arg) && !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) { /* don't separate references for __call */ arg = Z_REFVAL_P(arg); } - if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } } - ZVAL_COPY_VALUE(param, arg); + ZVAL_COPY(param, arg); ZEND_CALL_NUM_ARGS(EX(call))++; arg_num++; param++; @@ -4868,7 +4594,6 @@ ZEND_VM_HANDLER(120, ZEND_SEND_USER, VAR|CV, NUM) if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) { if (UNEXPECTED(!Z_ISREF_P(arg))) { - 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", @@ -4886,26 +4611,20 @@ ZEND_VM_HANDLER(120, ZEND_SEND_USER, VAR|CV, NUM) ZVAL_UNDEF(param); EX(call)->func = (zend_function*)&zend_pass_function; Z_OBJ(EX(call)->This) = NULL; - ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call))); + ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call)) & ~ZEND_CALL_RELEASE_THIS); FREE_OP1(); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - - ZVAL_NEW_REF(arg, arg); } - Z_ADDREF_P(arg); } else { if (Z_ISREF_P(arg) && !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) { /* don't separate references for __call */ arg = Z_REFVAL_P(arg); } - if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } } - ZVAL_COPY_VALUE(param, arg); + ZVAL_COPY(param, arg); FREE_OP1(); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -4924,7 +4643,7 @@ ZEND_VM_HANDLER(63, ZEND_RECV, NUM, ANY) zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var); SAVE_OPLINE(); - if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num)))) { + if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num)) || EG(exception))) { HANDLE_EXCEPTION(); } } @@ -4943,17 +4662,13 @@ ZEND_VM_HANDLER(64, ZEND_RECV_INIT, NUM, CONST) arg_num = opline->op1.num; param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var); if (arg_num > EX_NUM_ARGS()) { - ZVAL_COPY_VALUE(param, EX_CONSTANT(opline->op2)); + ZVAL_COPY(param, EX_CONSTANT(opline->op2)); if (Z_OPT_CONSTANT_P(param)) { SAVE_OPLINE(); - if (UNEXPECTED(zval_update_constant_ex(param, 0, NULL) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(param, EX(func)->op_array.scope) != SUCCESS)) { ZVAL_UNDEF(param); HANDLE_EXCEPTION(); } - } else { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(param))) { - Z_ADDREF_P(param); - } } } @@ -4961,7 +4676,7 @@ ZEND_VM_HANDLER(64, ZEND_RECV_INIT, NUM, CONST) zval *default_value = EX_CONSTANT(opline->op2); SAVE_OPLINE(); - if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, default_value, CACHE_ADDR(Z_CACHE_SLOT_P(default_value))))) { + if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, default_value, CACHE_ADDR(Z_CACHE_SLOT_P(default_value))) || EG(exception))) { HANDLE_EXCEPTION(); } } @@ -5178,7 +4893,7 @@ ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMPVAR|UNUSED|THIS|CV, ANY) USE_OPLINE zend_free_op free_op1; zval *obj; - zend_class_entry *ce; + zend_class_entry *ce, *scope; zend_function *clone; zend_object_clone_obj_t clone_call; @@ -5224,16 +4939,18 @@ ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMPVAR|UNUSED|THIS|CV, ANY) if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) { /* Ensure that if we're calling a private function, we're allowed to do so. */ - if (UNEXPECTED(ce != EG(scope))) { - zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = EX(func)->op_array.scope; + if (UNEXPECTED(ce != scope)) { + zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), scope ? ZSTR_VAL(scope->name) : ""); FREE_OP1(); HANDLE_EXCEPTION(); } } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ - if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { - zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = EX(func)->op_array.scope; + if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) { + zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), scope ? ZSTR_VAL(scope->name) : ""); FREE_OP1(); HANDLE_EXCEPTION(); } @@ -5295,7 +5012,7 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, UNUSED, CONST, CONST_FETCH) ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CONST) { - zend_class_entry *ce; + zend_class_entry *ce, *scope; zend_class_constant *c; zval *value; USE_OPLINE @@ -5338,15 +5055,14 @@ ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CO } if (EXPECTED((c = zend_hash_find_ptr(&ce->constants_table, Z_STR_P(EX_CONSTANT(opline->op2)))) != NULL)) { - if (!zend_verify_const_access(c, EG(scope))) { + scope = EX(func)->op_array.scope; + if (!zend_verify_const_access(c, scope)) { zend_throw_error(NULL, "Cannot access %s const %s::%s", zend_visibility_string(Z_ACCESS_FLAGS(c->value)), ZSTR_VAL(ce->name), Z_STRVAL_P(EX_CONSTANT(opline->op2))); HANDLE_EXCEPTION(); } value = &c->value; if (Z_CONSTANT_P(value)) { - EG(scope) = ce; - zval_update_constant_ex(value, 1, NULL); - EG(scope) = EX(func)->op_array.scope; + zval_update_constant_ex(value, ce); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } @@ -5605,89 +5321,20 @@ ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY, TYPE) ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) { USE_OPLINE - zend_op_array *new_op_array=NULL; + zend_op_array *new_op_array; zend_free_op free_op1; zval *inc_filename; - zval tmp_inc_filename; - zend_bool failure_retval=0; SAVE_OPLINE(); - inc_filename = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); - - ZVAL_UNDEF(&tmp_inc_filename); - if (Z_TYPE_P(inc_filename) != IS_STRING) { - if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(inc_filename) == IS_UNDEF)) { - inc_filename = GET_OP1_UNDEF_CV(inc_filename, BP_VAR_R); - } - ZVAL_STR(&tmp_inc_filename, zval_get_string(inc_filename)); - inc_filename = &tmp_inc_filename; - } - - if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { - if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { - zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename)); - } else { - zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename)); - } - } else { - switch (opline->extended_value) { - case ZEND_INCLUDE_ONCE: - case ZEND_REQUIRE_ONCE: { - zend_file_handle file_handle; - zend_string *resolved_path; - - resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), (int)Z_STRLEN_P(inc_filename)); - if (resolved_path) { - failure_retval = zend_hash_exists(&EG(included_files), resolved_path); - } else { - resolved_path = zend_string_copy(Z_STR_P(inc_filename)); - } - - if (failure_retval) { - /* do nothing, file already included */ - } else if (SUCCESS == zend_stream_open(ZSTR_VAL(resolved_path), &file_handle)) { - - if (!file_handle.opened_path) { - file_handle.opened_path = zend_string_copy(resolved_path); - } - - if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path)) { - new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE)); - zend_destroy_file_handle(&file_handle); - } else { - zend_file_handle_dtor(&file_handle); - failure_retval=1; - } - } else { - if (opline->extended_value == ZEND_INCLUDE_ONCE) { - zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename)); - } else { - zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename)); - } - } - zend_string_release(resolved_path); - } - break; - case ZEND_INCLUDE: - case ZEND_REQUIRE: - new_op_array = compile_filename(opline->extended_value, inc_filename); - break; - case ZEND_EVAL: { - char *eval_desc = zend_make_compiled_string_description("eval()'d code"); - - new_op_array = zend_compile_string(inc_filename, eval_desc); - efree(eval_desc); - } - break; - EMPTY_SWITCH_DEFAULT_CASE() - } - } - if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) { - zend_string_release(Z_STR(tmp_inc_filename)); - } + inc_filename = GET_OP1_ZVAL_PTR(BP_VAR_R); + new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); FREE_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); + } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + } } else if (EXPECTED(new_op_array != NULL)) { zval *return_value = NULL; zend_execute_data *call; @@ -5696,21 +5343,21 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) return_value = EX_VAR(opline->result.var); } - new_op_array->scope = EG(scope); + new_op_array->scope = EX(func)->op_array.scope; - call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE, + call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, (zend_function*)new_op_array, 0, Z_TYPE(EX(This)) != IS_OBJECT ? Z_CE(EX(This)) : NULL, Z_TYPE(EX(This)) == IS_OBJECT ? Z_OBJ(EX(This)) : NULL); - if (EX(symbol_table)) { + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { call->symbol_table = EX(symbol_table); } else { call->symbol_table = zend_rebuild_symbol_table(); } call->prev_execute_data = execute_data; - i_init_code_execute_data(call, new_op_array, return_value); + i_init_code_execute_data(call, new_op_array, return_value); if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -5725,12 +5372,11 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) zend_throw_exception_internal(NULL); HANDLE_EXCEPTION(); } - } else if (RETURN_VALUE_USED(opline)) { - ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval); + ZVAL_FALSE(EX_VAR(opline->result.var)); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|ISSET) @@ -5856,7 +5502,7 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV) zend_string *key; SAVE_OPLINE(); - container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET); + container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_UNSET); if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); FREE_UNFETCHED_OP2(); @@ -5921,6 +5567,9 @@ ZEND_VM_C_LABEL(num_index_dim): ZEND_VM_C_GOTO(unset_dim_array); } } + if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_R); + } if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R); } @@ -6771,7 +6420,7 @@ ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, CONST|TMPVAR|UNUSED|THIS|CV, CO zval *offset; SAVE_OPLINE(); - container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS); + container = GET_OP1_OBJ_ZVAL_PTR_UNDEF(BP_VAR_IS); if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); @@ -7047,9 +6696,10 @@ ZEND_VM_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, JMP_ADDR) } else if (OP1_TYPE == IS_VAR && ref) { zend_reference *r = Z_REF_P(ref); - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) { efree_size(r, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); } } ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); @@ -7087,9 +6737,10 @@ ZEND_VM_HANDLER(169, ZEND_COALESCE, CONST|TMP|VAR|CV, JMP_ADDR) } else if (OP1_TYPE == IS_VAR && ref) { zend_reference *r = Z_REF_P(ref); - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) { efree_size(r, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); } } ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); @@ -7104,30 +6755,36 @@ ZEND_VM_HANDLER(22, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY) USE_OPLINE zend_free_op free_op1; zval *value; + zval *result = EX_VAR(opline->result.var); value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { SAVE_OPLINE(); GET_OP1_UNDEF_CV(value, BP_VAR_R); - ZVAL_NULL(EX_VAR(opline->result.var)); + ZVAL_NULL(result); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && Z_ISREF_P(value)) { - ZVAL_COPY(EX_VAR(opline->result.var), Z_REFVAL_P(value)); - if (OP1_TYPE == IS_VAR) { + if (OP1_TYPE == IS_CV) { + ZVAL_DEREF(value); + ZVAL_COPY(result, value); + } else if (OP1_TYPE == IS_VAR) { + if (UNEXPECTED(Z_ISREF_P(value))) { + ZVAL_COPY_VALUE(result, Z_REFVAL_P(value)); if (UNEXPECTED(Z_DELREF_P(value) == 0)) { efree_size(Z_REF_P(value), sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); } + } else { + ZVAL_COPY_VALUE(result, value); } } else { - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); + ZVAL_COPY_VALUE(result, value); if (OP1_TYPE == IS_CONST) { if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) { - zval_copy_ctor_func(EX_VAR(opline->result.var)); + zval_copy_ctor_func(result); } - } else if (OP1_TYPE == IS_CV) { - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); } } ZEND_VM_NEXT_OPCODE(); @@ -7399,8 +7056,6 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) uint32_t catch_op_num = 0, finally_op_num = 0, finally_op_end = 0; int in_finally = 0; - ZEND_VM_INTERRUPT_CHECK(); - { const zend_op *exc_opline = EG(opline_before_exception); if ((exc_opline->opcode == ZEND_FREE || exc_opline->opcode == ZEND_FE_FREE) @@ -7523,17 +7178,13 @@ ZEND_VM_HANDLER(143, ZEND_DECLARE_CONST, CONST, CONST) name = GET_OP1_ZVAL_PTR(BP_VAR_R); val = GET_OP2_ZVAL_PTR(BP_VAR_R); - ZVAL_COPY_VALUE(&c.value, val); + ZVAL_COPY(&c.value, val); if (Z_OPT_CONSTANT(c.value)) { - if (UNEXPECTED(zval_update_constant_ex(&c.value, 0, NULL) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) { FREE_OP1(); FREE_OP2(); HANDLE_EXCEPTION(); } - } else { - if (UNEXPECTED(Z_OPT_REFCOUNTED(c.value))) { - Z_ADDREF(c.value); - } } c.flags = CONST_CS; /* non persistent, case sensetive */ c.name = zend_string_dup(Z_STR_P(name), 0); @@ -7572,7 +7223,7 @@ ZEND_VM_HANDLER(153, ZEND_DECLARE_LAMBDA_FUNCTION, CONST, UNUSED) object = NULL; } zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), - EG(scope), called_scope, object); + EX(func)->op_array.scope, called_scope, object); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -7587,10 +7238,8 @@ ZEND_VM_HANDLER(156, ZEND_SEPARATE, VAR, UNUSED) if (UNEXPECTED(Z_REFCOUNT_P(var_ptr) == 1)) { ZVAL_UNREF(var_ptr); } - } else if (Z_COPYABLE_P(var_ptr) && Z_REFCOUNT_P(var_ptr) > 1) { - Z_DELREF_P(var_ptr); - ZVAL_DUP(EX_VAR(opline->op1.var), var_ptr); } + ZEND_VM_NEXT_OPCODE(); } @@ -7641,7 +7290,7 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE 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)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -7862,10 +7511,10 @@ ZEND_VM_HANDLER(163, ZEND_FAST_RET, ANY, TRY_CATCH, FAST_RET) 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 = EX(func)->op_array.try_catch_array[fast_ret->op2.num].finally_op - 2; } + ZEND_VM_SET_OPCODE(fast_ret + 1); ZEND_VM_CONTINUE(); } else { /* special case for unhandled exceptions */ @@ -8107,13 +7756,14 @@ ZEND_VM_HANDLER(151, ZEND_ASSERT_CHECK, ANY, JMP_ADDR) ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, ANY, ANY, CLASS_FETCH) { uint32_t fetch_type; - zend_class_entry *called_scope; + zend_class_entry *called_scope, *scope; USE_OPLINE SAVE_OPLINE(); fetch_type = opline->extended_value; - if (UNEXPECTED(EG(scope) == NULL)) { + scope = EX(func)->op_array.scope; + if (UNEXPECTED(scope == NULL)) { zend_throw_error(NULL, "Cannot use \"%s\" when no class scope is active", fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); @@ -8122,15 +7772,15 @@ ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, ANY, ANY, CLASS_FETCH) switch (fetch_type) { case ZEND_FETCH_CLASS_SELF: - ZVAL_STR_COPY(EX_VAR(opline->result.var), EG(scope)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name); break; case ZEND_FETCH_CLASS_PARENT: - if (UNEXPECTED(EG(scope)->parent == NULL)) { + if (UNEXPECTED(scope->parent == NULL)) { zend_throw_error(NULL, "Cannot use \"parent\" when current class scope has no parent"); HANDLE_EXCEPTION(); } - ZVAL_STR_COPY(EX_VAR(opline->result.var), EG(scope)->parent->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name); break; case ZEND_FETCH_CLASS_STATIC: if (Z_TYPE(EX(This)) == IS_OBJECT) { @@ -8188,7 +7838,6 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) ZEND_ASSERT(!(fbc->common.fn_flags & ZEND_ACC_GENERATOR)); - call->symbol_table = NULL; if (UNEXPECTED(!fbc->op_array.run_time_cache)) { init_func_run_time_cache(&fbc->op_array); } @@ -8207,32 +7856,19 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) EG(current_execute_data) = call; - 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); - - EG(current_execute_data) = call; - - for (i = 0; i < num_args; ++i) { - if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) { - EG(current_execute_data) = call->prev_execute_data; - zend_vm_stack_free_args(call); - zend_vm_stack_free_call_frame(call); - if (ret) { - ZVAL_UNDEF(ret); - } - ZEND_VM_C_GOTO(call_trampoline_end); - } - p++; + if (UNEXPECTED(fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) + && UNEXPECTED(!zend_verify_internal_arg_types(fbc, call))) { + zend_vm_stack_free_call_frame(call); + if (ret) { + ZVAL_UNDEF(ret); } + ZEND_VM_C_GOTO(call_trampoline_end); } if (ret == NULL) { ZVAL_NULL(&retval); ret = &retval; } - 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 */ @@ -8270,7 +7906,6 @@ ZEND_VM_C_LABEL(call_trampoline_end): zend_object *object = Z_OBJ(call->This); OBJ_RELEASE(object); } - EG(scope) = EX(func)->op_array.scope; zend_vm_stack_free_call_frame(call); if (UNEXPECTED(EG(exception) != NULL)) { @@ -8343,7 +7978,7 @@ ZEND_VM_HANDLER(183, ZEND_BIND_STATIC, CV, CONST, REF) if (opline->extended_value) { if (Z_CONSTANT_P(value)) { - if (UNEXPECTED(zval_update_constant_ex(value, 1, NULL) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(value, EX(func)->op_array.scope) != SUCCESS)) { ZVAL_NULL(variable_ptr); HANDLE_EXCEPTION(); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 0b3bafecf0..9a74e53e29 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -387,7 +387,7 @@ typedef ZEND_OPCODE_HANDLER_RET (ZEND_FASTCALL *opcode_handler_t) (ZEND_OPCODE_H #define HANDLE_EXCEPTION() LOAD_OPLINE(); ZEND_VM_CONTINUE() #define HANDLE_EXCEPTION_LEAVE() LOAD_OPLINE(); ZEND_VM_LEAVE() #if defined(ZEND_VM_FP_GLOBAL_REG) -# define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_CONTINUE() +# define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_INTERRUPT_CHECK(); ZEND_VM_CONTINUE() # define ZEND_VM_LEAVE() ZEND_VM_CONTINUE() #elif defined(ZEND_VM_IP_GLOBAL_REG) # define ZEND_VM_ENTER() opline = EG(current_execute_data)->opline; return 1 @@ -415,6 +415,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) LOAD_OPLINE(); + ZEND_VM_INTERRUPT_CHECK(); while (1) { #if !defined(ZEND_VM_FP_GLOBAL_REG) || !defined(ZEND_VM_IP_GLOBAL_REG) @@ -435,6 +436,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) #else if (EXPECTED(ret > 0)) { execute_data = EG(current_execute_data); + ZEND_VM_INTERRUPT_CHECK(); } else { # ifdef ZEND_VM_IP_GLOBAL_REG opline = orig_opline; @@ -456,7 +458,7 @@ ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value) return; } - execute_data = zend_vm_stack_push_call_frame(ZEND_CALL_TOP_CODE, + execute_data = zend_vm_stack_push_call_frame(ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, (zend_function*)op_array, 0, zend_get_called_scope(EG(current_execute_data)), zend_get_this_object(EG(current_execute_data))); if (EG(current_execute_data)) { execute_data->symbol_table = zend_rebuild_symbol_table(); @@ -475,34 +477,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_ uint32_t call_info = EX_CALL_INFO(); if (EXPECTED(ZEND_CALL_KIND_EX(call_info) == ZEND_CALL_NESTED_FUNCTION)) { - zend_object *object; - i_free_compiled_variables(execute_data); - if (UNEXPECTED(call_info & ZEND_CALL_FREE_SYMBOL_TABLE)) { - zend_clean_and_cache_symbol_table(EX(symbol_table)); - } - zend_vm_stack_free_extra_args_ex(call_info, execute_data); - old_execute_data = execute_data; - execute_data = EG(current_execute_data) = EX(prev_execute_data); - if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) { - object = Z_OBJ(old_execute_data->This); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED))) { + if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) { + zend_clean_and_cache_symbol_table(EX(symbol_table)); + } + EG(current_execute_data) = EX(prev_execute_data); + if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) { + zend_object *object = Z_OBJ(execute_data->This); #if 0 - if (UNEXPECTED(EG(exception) != NULL) && (EX(opline)->op1.num & ZEND_CALL_CTOR)) { + if (UNEXPECTED(EG(exception) != NULL) && (EX(opline)->op1.num & ZEND_CALL_CTOR)) { #else - if (UNEXPECTED(EG(exception) != NULL) && (call_info & ZEND_CALL_CTOR)) { + if (UNEXPECTED(EG(exception) != NULL) && (call_info & ZEND_CALL_CTOR)) { #endif - GC_REFCOUNT(object)--; - if (GC_REFCOUNT(object) == 1) { - zend_object_store_ctor_failed(object); + GC_REFCOUNT(object)--; + if (GC_REFCOUNT(object) == 1) { + zend_object_store_ctor_failed(object); + } } + OBJ_RELEASE(object); + } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { + OBJ_RELEASE((zend_object*)execute_data->func->op_array.prototype); } - OBJ_RELEASE(object); - } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { - OBJ_RELEASE((zend_object*)old_execute_data->func->op_array.prototype); - } - EG(scope) = EX(func)->op_array.scope; - zend_vm_stack_free_call_frame_ex(call_info, old_execute_data); + zend_vm_stack_free_extra_args_ex(call_info, execute_data); + old_execute_data = execute_data; + execute_data = EX(prev_execute_data); + zend_vm_stack_free_call_frame_ex(call_info, old_execute_data); + } else { + EG(current_execute_data) = EX(prev_execute_data); + if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) { + zend_object *object = Z_OBJ(execute_data->This); +#if 0 + if (UNEXPECTED(EG(exception) != NULL) && (EX(opline)->op1.num & ZEND_CALL_CTOR)) { +#else + if (UNEXPECTED(EG(exception) != NULL) && (call_info & ZEND_CALL_CTOR)) { +#endif + GC_REFCOUNT(object)--; + if (GC_REFCOUNT(object) == 1) { + zend_object_store_ctor_failed(object); + } + } + OBJ_RELEASE(object); + } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { + OBJ_RELEASE((zend_object*)execute_data->func->op_array.prototype); + } + EG(vm_stack_top) = (zval*)execute_data; + execute_data = EX(prev_execute_data); + } if (UNEXPECTED(EG(exception) != NULL)) { const zend_op *old_opline = EX(opline); @@ -515,8 +537,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_ LOAD_NEXT_OPLINE(); ZEND_VM_LEAVE(); - } - if (EXPECTED((ZEND_CALL_KIND_EX(call_info) & ZEND_CALL_TOP) == 0)) { + } else if (EXPECTED((ZEND_CALL_KIND_EX(call_info) & ZEND_CALL_TOP) == 0)) { zend_detach_symbol_table(execute_data); destroy_op_array(&EX(func)->op_array); efree_size(EX(func), sizeof(zend_op_array)); @@ -535,21 +556,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_ } else { if (ZEND_CALL_KIND_EX(call_info) == ZEND_CALL_TOP_FUNCTION) { i_free_compiled_variables(execute_data); - if (UNEXPECTED(call_info & ZEND_CALL_FREE_SYMBOL_TABLE)) { - zend_clean_and_cache_symbol_table(EX(symbol_table)); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS))) { + if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) { + zend_clean_and_cache_symbol_table(EX(symbol_table)); + } + zend_vm_stack_free_extra_args_ex(call_info, execute_data); } - zend_vm_stack_free_extra_args_ex(call_info, execute_data); EG(current_execute_data) = EX(prev_execute_data); if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { OBJ_RELEASE((zend_object*)EX(func)->op_array.prototype); } + ZEND_VM_RETURN(); } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ { zend_array *symbol_table = EX(symbol_table); zend_detach_symbol_table(execute_data); old_execute_data = EX(prev_execute_data); while (old_execute_data) { - if (old_execute_data->func && ZEND_USER_CODE(old_execute_data->func->op_array.type)) { + if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) { if (old_execute_data->symbol_table == symbol_table) { zend_attach_symbol_table(old_execute_data); } @@ -558,9 +582,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_ old_execute_data = old_execute_data->prev_execute_data; } EG(current_execute_data) = EX(prev_execute_data); + ZEND_VM_RETURN(); } - - ZEND_VM_RETURN(); } } @@ -588,7 +611,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HA ret = 0 ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); - Z_VAR_FLAGS_P(ret) = 0; fbc->internal_function.handler(call, ret); @@ -597,6 +619,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HA EG(exception) || !call->func || !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT(!Z_ISREF_P(ret)); #endif EG(current_execute_data) = call->prev_execute_data; @@ -615,8 +638,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HA HANDLE_EXCEPTION(); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -635,7 +658,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_USED_HAND ret = 1 ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); - Z_VAR_FLAGS_P(ret) = 0; fbc->internal_function.handler(call, ret); @@ -644,6 +666,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_USED_HAND EG(exception) || !call->func || !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT(!Z_ISREF_P(ret)); #endif EG(current_execute_data) = call->prev_execute_data; @@ -662,8 +685,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_USED_HAND HANDLE_EXCEPTION(); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -676,13 +699,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HA SAVE_OPLINE(); EX(call) = call->prev_execute_data; - EG(scope) = NULL; ret = NULL; - call->symbol_table = NULL; if (0) { ret = EX_VAR(opline->result.var); ZVAL_NULL(ret); - Z_VAR_FLAGS_P(ret) = 0; } call->prev_execute_data = execute_data; @@ -701,13 +721,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_USED_HAND SAVE_OPLINE(); EX(call) = call->prev_execute_data; - EG(scope) = NULL; ret = NULL; - call->symbol_table = NULL; if (1) { ret = EX_VAR(opline->result.var); ZVAL_NULL(ret); - Z_VAR_FLAGS_P(ret) = 0; } call->prev_execute_data = execute_data; @@ -727,12 +744,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_U 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 (EXPECTED(0)) { ret = EX_VAR(opline->result.var); zend_generator_create_zval(call, &fbc->op_array, ret); - Z_VAR_FLAGS_P(ret) = 0; } else { zend_vm_stack_free_args(call); } @@ -740,11 +755,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_U zend_vm_stack_free_call_frame(call); } else { ret = NULL; - call->symbol_table = NULL; if (0) { ret = EX_VAR(opline->result.var); ZVAL_NULL(ret); - Z_VAR_FLAGS_P(ret) = 0; } call->prev_execute_data = execute_data; @@ -752,7 +765,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_U ZEND_VM_ENTER(); } - EG(scope) = EX(func)->op_array.scope; } else { zval retval; ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); @@ -770,34 +782,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_U call->prev_execute_data = execute_data; EG(current_execute_data) = call; - 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); - - for (i = 0; i < num_args; ++i) { - if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) { - 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(); - } - p++; - } + if (UNEXPECTED(fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) + && UNEXPECTED(!zend_verify_internal_arg_types(fbc, call))) { + zend_vm_stack_free_call_frame(call); + zend_throw_exception_internal(NULL); + HANDLE_EXCEPTION(); } ret = 0 ? EX_VAR(opline->result.var) : &retval; 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); #if ZEND_DEBUG - ZEND_ASSERT( - EG(exception) || !call->func || - !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || - zend_verify_internal_return_type(call->func, ret)); + if (!EG(exception) && call->func) { + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } #endif EG(current_execute_data) = call->prev_execute_data; @@ -816,8 +819,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_U } HANDLE_EXCEPTION(); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -831,12 +834,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_U 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 (EXPECTED(1)) { ret = EX_VAR(opline->result.var); zend_generator_create_zval(call, &fbc->op_array, ret); - Z_VAR_FLAGS_P(ret) = 0; } else { zend_vm_stack_free_args(call); } @@ -844,11 +845,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_U zend_vm_stack_free_call_frame(call); } else { ret = NULL; - call->symbol_table = NULL; if (1) { ret = EX_VAR(opline->result.var); ZVAL_NULL(ret); - Z_VAR_FLAGS_P(ret) = 0; } call->prev_execute_data = execute_data; @@ -856,7 +855,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_U ZEND_VM_ENTER(); } - EG(scope) = EX(func)->op_array.scope; } else { zval retval; ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); @@ -874,34 +872,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_U call->prev_execute_data = execute_data; EG(current_execute_data) = call; - 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); - - for (i = 0; i < num_args; ++i) { - if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) { - 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(); - } - p++; - } + if (UNEXPECTED(fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) + && UNEXPECTED(!zend_verify_internal_arg_types(fbc, call))) { + zend_vm_stack_free_call_frame(call); + zend_throw_exception_internal(NULL); + HANDLE_EXCEPTION(); } ret = 1 ? EX_VAR(opline->result.var) : &retval; 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); #if ZEND_DEBUG - ZEND_ASSERT( - EG(exception) || !call->func || - !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || - zend_verify_internal_return_type(call->func, ret)); + if (!EG(exception) && call->func) { + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } #endif EG(current_execute_data) = call->prev_execute_data; @@ -920,8 +909,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_U } HANDLE_EXCEPTION(); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -953,12 +942,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HA LOAD_OPLINE(); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { - EG(scope) = fbc->common.scope; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_GENERATOR) != 0)) { if (EXPECTED(0)) { ret = EX_VAR(opline->result.var); zend_generator_create_zval(call, &fbc->op_array, ret); - Z_VAR_FLAGS_P(ret) = 0; } else { if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) { OBJ_RELEASE((zend_object*)fbc->op_array.prototype); @@ -967,11 +954,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HA } } else { ret = NULL; - call->symbol_table = NULL; if (0) { ret = EX_VAR(opline->result.var); ZVAL_NULL(ret); - Z_VAR_FLAGS_P(ret) = 0; } call->prev_execute_data = execute_data; @@ -985,42 +970,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HA } } } else if (EXPECTED(fbc->type < ZEND_USER_FUNCTION)) { - int should_change_scope = 0; zval retval; - if (fbc->common.scope) { - should_change_scope = 1; - EG(scope) = fbc->common.scope; - } - call->prev_execute_data = execute_data; EG(current_execute_data) = call; - 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); - - for (i = 0; i < num_args; ++i) { - if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) { - EG(current_execute_data) = call->prev_execute_data; - zend_vm_stack_free_args(call); - if (0) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - } - if (UNEXPECTED(should_change_scope)) { - goto fcall_end_change_scope; - } else { - goto fcall_end; - } - } - p++; + if (UNEXPECTED(fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) + && UNEXPECTED(!zend_verify_internal_arg_types(fbc, call))) { + if (0) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); } + goto fcall_end; } ret = 0 ? EX_VAR(opline->result.var) : &retval; 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 */ @@ -1030,10 +994,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HA } #if ZEND_DEBUG - ZEND_ASSERT( - EG(exception) || !call->func || - !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || - zend_verify_internal_return_type(call->func, ret)); + if (!EG(exception) && call->func) { + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } #endif EG(current_execute_data) = call->prev_execute_data; @@ -1043,52 +1009,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HA zval_ptr_dtor(ret); } - if (UNEXPECTED(should_change_scope)) { - goto fcall_end_change_scope; - } else { - goto fcall_end; - } } else { /* ZEND_OVERLOADED_FUNCTION */ zval retval; - /* Not sure what should be done here if it's a static method */ - if (UNEXPECTED(Z_TYPE(call->This) != IS_OBJECT)) { - zend_vm_stack_free_args(call); - if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { - zend_string_release(fbc->common.function_name); - } - efree(fbc); - zend_vm_stack_free_call_frame(call); - - zend_throw_error(NULL, "Cannot call overloaded function for non-object"); - HANDLE_EXCEPTION(); - } - - object = Z_OBJ(call->This); - EG(scope) = fbc->common.scope; ret = 0 ? EX_VAR(opline->result.var) : &retval; - ZVAL_NULL(ret); call->prev_execute_data = execute_data; - EG(current_execute_data) = call; - object->handlers->call_method(fbc->common.function_name, object, call, ret); - EG(current_execute_data) = call->prev_execute_data; - zend_vm_stack_free_args(call); - - if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { - zend_string_release(fbc->common.function_name); + if (UNEXPECTED(!zend_do_fcall_overloaded(fbc, call, ret))) { + HANDLE_EXCEPTION(); } - efree(fbc); if (!0) { zval_ptr_dtor(ret); - } else { - Z_VAR_FLAGS_P(ret) = 0; } } -fcall_end_change_scope: +fcall_end: if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) { object = Z_OBJ(call->This); #if 0 @@ -1103,9 +1040,7 @@ fcall_end_change_scope: } OBJ_RELEASE(object); } - EG(scope) = EX(func)->op_array.scope; -fcall_end: zend_vm_stack_free_call_frame(call); if (UNEXPECTED(EG(exception) != NULL)) { zend_throw_exception_internal(NULL); @@ -1115,8 +1050,8 @@ fcall_end: HANDLE_EXCEPTION(); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -1148,12 +1083,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_HAND LOAD_OPLINE(); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { - EG(scope) = fbc->common.scope; if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_GENERATOR) != 0)) { if (EXPECTED(1)) { ret = EX_VAR(opline->result.var); zend_generator_create_zval(call, &fbc->op_array, ret); - Z_VAR_FLAGS_P(ret) = 0; } else { if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) { OBJ_RELEASE((zend_object*)fbc->op_array.prototype); @@ -1162,11 +1095,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_HAND } } else { ret = NULL; - call->symbol_table = NULL; if (1) { ret = EX_VAR(opline->result.var); ZVAL_NULL(ret); - Z_VAR_FLAGS_P(ret) = 0; } call->prev_execute_data = execute_data; @@ -1180,42 +1111,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_HAND } } } else if (EXPECTED(fbc->type < ZEND_USER_FUNCTION)) { - int should_change_scope = 0; zval retval; - if (fbc->common.scope) { - should_change_scope = 1; - EG(scope) = fbc->common.scope; - } - call->prev_execute_data = execute_data; EG(current_execute_data) = call; - 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); - - for (i = 0; i < num_args; ++i) { - if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) { - EG(current_execute_data) = call->prev_execute_data; - zend_vm_stack_free_args(call); - if (1) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - } - if (UNEXPECTED(should_change_scope)) { - goto fcall_end_change_scope; - } else { - goto fcall_end; - } - } - p++; + if (UNEXPECTED(fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) + && UNEXPECTED(!zend_verify_internal_arg_types(fbc, call))) { + if (1) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); } + goto fcall_end; } ret = 1 ? EX_VAR(opline->result.var) : &retval; 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 */ @@ -1225,10 +1135,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_HAND } #if ZEND_DEBUG - ZEND_ASSERT( - EG(exception) || !call->func || - !(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || - zend_verify_internal_return_type(call->func, ret)); + if (!EG(exception) && call->func) { + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } #endif EG(current_execute_data) = call->prev_execute_data; @@ -1238,52 +1150,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_HAND zval_ptr_dtor(ret); } - if (UNEXPECTED(should_change_scope)) { - goto fcall_end_change_scope; - } else { - goto fcall_end; - } } else { /* ZEND_OVERLOADED_FUNCTION */ zval retval; - /* Not sure what should be done here if it's a static method */ - if (UNEXPECTED(Z_TYPE(call->This) != IS_OBJECT)) { - zend_vm_stack_free_args(call); - if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { - zend_string_release(fbc->common.function_name); - } - efree(fbc); - zend_vm_stack_free_call_frame(call); - - zend_throw_error(NULL, "Cannot call overloaded function for non-object"); - HANDLE_EXCEPTION(); - } - - object = Z_OBJ(call->This); - EG(scope) = fbc->common.scope; ret = 1 ? EX_VAR(opline->result.var) : &retval; - ZVAL_NULL(ret); call->prev_execute_data = execute_data; - EG(current_execute_data) = call; - object->handlers->call_method(fbc->common.function_name, object, call, ret); - EG(current_execute_data) = call->prev_execute_data; - - zend_vm_stack_free_args(call); - if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { - zend_string_release(fbc->common.function_name); + if (UNEXPECTED(!zend_do_fcall_overloaded(fbc, call, ret))) { + HANDLE_EXCEPTION(); } - efree(fbc); if (!1) { zval_ptr_dtor(ret); - } else { - Z_VAR_FLAGS_P(ret) = 0; } } -fcall_end_change_scope: +fcall_end: if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) { object = Z_OBJ(call->This); #if 0 @@ -1298,9 +1181,7 @@ fcall_end_change_scope: } OBJ_RELEASE(object); } - EG(scope) = EX(func)->op_array.scope; -fcall_end: zend_vm_stack_free_call_frame(call); if (UNEXPECTED(EG(exception) != NULL)) { zend_throw_exception_internal(NULL); @@ -1310,8 +1191,8 @@ fcall_end: HANDLE_EXCEPTION(); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -1333,7 +1214,7 @@ send_again: zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht)); - if (opline->op1_type != IS_CONST && opline->op1_type != IS_TMP_VAR && Z_IMMUTABLE_P(args)) { + if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) { uint32_t i; int separate = 0; @@ -1345,7 +1226,7 @@ send_again: } } if (separate) { - zval_copy_ctor(args); + SEPARATE_ARRAY(args); ht = Z_ARRVAL_P(args); } } @@ -1359,7 +1240,7 @@ send_again: top = ZEND_CALL_ARG(EX(call), arg_num); if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - if (!Z_IMMUTABLE_P(args)) { + if (Z_REFCOUNT_P(args) == 1) { ZVAL_MAKE_REF(arg); Z_ADDREF_P(arg); ZVAL_REF(top, Z_REF_P(arg)); @@ -1501,7 +1382,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O } EX(call)->func = (zend_function*)&zend_pass_function; Z_OBJ(EX(call)->This) = NULL; - ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call))); + ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call)) & ~ZEND_CALL_RELEASE_THIS); } else { uint32_t arg_num; HashTable *ht; @@ -1511,22 +1392,6 @@ send_array: ht = Z_ARRVAL_P(args); zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht)); - if (opline->op1_type != IS_CONST && opline->op1_type != IS_TMP_VAR && Z_IMMUTABLE_P(args)) { - int separate = 0; - - /* check if any of arguments are going to be passed by reference */ - for (arg_num = 0; arg_num < zend_hash_num_elements(ht); arg_num++) { - if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num + 1)) { - separate = 1; - break; - } - } - if (separate) { - zval_copy_ctor(args); - ht = Z_ARRVAL_P(args); - } - } - arg_num = 1; param = ZEND_CALL_ARG(EX(call), 1); ZEND_HASH_FOREACH_VAL(ht, arg) { @@ -1548,25 +1413,18 @@ send_array: } EX(call)->func = (zend_function*)&zend_pass_function; Z_OBJ(EX(call)->This) = NULL; - ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call))); - + ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call)) & ~ZEND_CALL_RELEASE_THIS); break; } - - ZVAL_NEW_REF(arg, arg); } - Z_ADDREF_P(arg); - } else{ + } else { if (Z_ISREF_P(arg) && !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) { /* don't separate references for __call */ arg = Z_REFVAL_P(arg); } - if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } } - ZVAL_COPY_VALUE(param, arg); + ZVAL_COPY(param, arg); ZEND_CALL_NUM_ARGS(EX(call))++; arg_num++; param++; @@ -1589,7 +1447,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_ zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var); SAVE_OPLINE(); - if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num)))) { + if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num)) || EG(exception))) { HANDLE_EXCEPTION(); } } @@ -1818,8 +1676,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( uint32_t catch_op_num = 0, finally_op_num = 0, finally_op_end = 0; int in_finally = 0; - ZEND_VM_INTERRUPT_CHECK(); - { const zend_op *exc_opline = EG(opline_before_exception); if ((exc_opline->opcode == ZEND_FREE || exc_opline->opcode == ZEND_FE_FREE) @@ -1969,10 +1825,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPC 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 = EX(func)->op_array.try_catch_array[fast_ret->op2.num].finally_op - 2; } + ZEND_VM_SET_OPCODE(fast_ret + 1); ZEND_VM_CONTINUE(); } else { /* special case for unhandled exceptions */ @@ -2025,13 +1881,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { uint32_t fetch_type; - zend_class_entry *called_scope; + zend_class_entry *called_scope, *scope; USE_OPLINE SAVE_OPLINE(); fetch_type = opline->extended_value; - if (UNEXPECTED(EG(scope) == NULL)) { + scope = EX(func)->op_array.scope; + if (UNEXPECTED(scope == NULL)) { zend_throw_error(NULL, "Cannot use \"%s\" when no class scope is active", fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); @@ -2040,15 +1897,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_HANDLER( switch (fetch_type) { case ZEND_FETCH_CLASS_SELF: - ZVAL_STR_COPY(EX_VAR(opline->result.var), EG(scope)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name); break; case ZEND_FETCH_CLASS_PARENT: - if (UNEXPECTED(EG(scope)->parent == NULL)) { + if (UNEXPECTED(scope->parent == NULL)) { zend_throw_error(NULL, "Cannot use \"parent\" when current class scope has no parent"); HANDLE_EXCEPTION(); } - ZVAL_STR_COPY(EX_VAR(opline->result.var), EG(scope)->parent->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name); break; case ZEND_FETCH_CLASS_STATIC: if (Z_TYPE(EX(This)) == IS_OBJECT) { @@ -2106,7 +1963,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z ZEND_ASSERT(!(fbc->common.fn_flags & ZEND_ACC_GENERATOR)); - call->symbol_table = NULL; if (UNEXPECTED(!fbc->op_array.run_time_cache)) { init_func_run_time_cache(&fbc->op_array); } @@ -2125,32 +1981,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z EG(current_execute_data) = call; - 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); - - EG(current_execute_data) = call; - - for (i = 0; i < num_args; ++i) { - if (UNEXPECTED(!zend_verify_internal_arg_type(fbc, i + 1, p))) { - EG(current_execute_data) = call->prev_execute_data; - zend_vm_stack_free_args(call); - zend_vm_stack_free_call_frame(call); - if (ret) { - ZVAL_UNDEF(ret); - } - goto call_trampoline_end; - } - p++; + if (UNEXPECTED(fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) + && UNEXPECTED(!zend_verify_internal_arg_types(fbc, call))) { + zend_vm_stack_free_call_frame(call); + if (ret) { + ZVAL_UNDEF(ret); } + goto call_trampoline_end; } if (ret == NULL) { ZVAL_NULL(&retval); ret = &retval; } - 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 */ @@ -2188,7 +2031,6 @@ call_trampoline_end: zend_object *object = Z_OBJ(call->This); OBJ_RELEASE(object); } - EG(scope) = EX(func)->op_array.scope; zend_vm_stack_free_call_frame(call); if (UNEXPECTED(EG(exception) != NULL)) { @@ -2278,195 +2120,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_function *fbc; - zval *function_name, *func; - zend_string *lcname; - zend_class_entry *called_scope; - zend_object *object; + zval *function_name; zend_execute_data *call; - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION; SAVE_OPLINE(); function_name = EX_CONSTANT(opline->op2); try_function_name: if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - const char *colon; - - if ((colon = zend_memrchr(Z_STRVAL_P(function_name), ':', Z_STRLEN_P(function_name))) != NULL && - colon > Z_STRVAL_P(function_name) && - *(colon-1) == ':' - ) { - zend_string *mname; - size_t cname_length = colon - Z_STRVAL_P(function_name) - 1; - size_t mname_length = Z_STRLEN_P(function_name) - cname_length - (sizeof("::") - 1); - - lcname = zend_string_init(Z_STRVAL_P(function_name), cname_length, 0); - - object = NULL; - called_scope = zend_fetch_class_by_name(lcname, NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(called_scope == NULL)) { - zend_string_release(lcname); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - mname = zend_string_init(Z_STRVAL_P(function_name) + (cname_length + sizeof("::") - 1), mname_length, 0); - - if (called_scope->get_static_method) { - fbc = called_scope->get_static_method(called_scope, mname); - } else { - fbc = zend_std_get_static_method(called_scope, mname, NULL); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), ZSTR_VAL(mname)); - } - zend_string_release(lcname); - zend_string_release(mname); - - HANDLE_EXCEPTION(); - } - - zend_string_release(lcname); - zend_string_release(mname); - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - - HANDLE_EXCEPTION(); - } - } - } else { - if (Z_STRVAL_P(function_name)[0] == '\\') { - lcname = zend_string_alloc(Z_STRLEN_P(function_name) - 1, 0); - zend_str_tolower_copy(ZSTR_VAL(lcname), 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)) { - zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name)); - zend_string_release(lcname); - - HANDLE_EXCEPTION(); - } - zend_string_release(lcname); - - fbc = Z_FUNC_P(func); - called_scope = NULL; - object = NULL; - } - - } else if (IS_CONST != 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 (fbc->common.fn_flags & ZEND_ACC_CLOSURE) { - /* Delay closure destruction until its invocation */ - ZEND_ASSERT(GC_TYPE((zend_object*)fbc->common.prototype) == IS_OBJECT); - GC_REFCOUNT((zend_object*)fbc->common.prototype)++; - call_info |= ZEND_CALL_CLOSURE; - } else if (object) { - call_info |= ZEND_CALL_RELEASE_THIS; - GC_REFCOUNT(object)++; /* For $this pointer */ - } - - } 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); - - if (!obj || !method) { - zend_throw_error(NULL, "Array callback has to contain indices 0 and 1"); - - HANDLE_EXCEPTION(); - } - - ZVAL_DEREF(obj); - if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) { - zend_throw_error(NULL, "First array member is not a valid class name or object"); - - HANDLE_EXCEPTION(); - } - - ZVAL_DEREF(method); - if (Z_TYPE_P(method) != IS_STRING) { - zend_throw_error(NULL, "Second array member is not a valid method"); - - HANDLE_EXCEPTION(); - } - - if (Z_TYPE_P(obj) == IS_STRING) { - object = NULL; - called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(called_scope == NULL)) { - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - 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); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), Z_STRVAL_P(method)); - } - - HANDLE_EXCEPTION(); - } - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - - HANDLE_EXCEPTION(); - } - } - } else { - 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)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(object->ce->name), Z_STRVAL_P(method)); - } - - HANDLE_EXCEPTION(); - } - - if ((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { - object = NULL; - } else { - call_info |= ZEND_CALL_RELEASE_THIS; - GC_REFCOUNT(object)++; /* For $this pointer */ - } - } - - } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(function_name) == IS_REFERENCE) { + call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value); + } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) { + call = zend_init_dynamic_call_object(function_name, opline->extended_value); + } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) { + call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value); + } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) { function_name = Z_REFVAL_P(function_name); goto try_function_name; } else { @@ -2477,14 +2145,13 @@ try_function_name: } } zend_throw_error(NULL, "Function name must be a string"); + call = NULL; + } + if (UNEXPECTED(!call)) { HANDLE_EXCEPTION(); } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) { - init_func_run_time_cache(&fbc->op_array); - } - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, called_scope, object); + call->prev_execute_data = EX(call); EX(call) = call; @@ -2571,17 +2238,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(Z arg_num = opline->op1.num; param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var); if (arg_num > EX_NUM_ARGS()) { - ZVAL_COPY_VALUE(param, EX_CONSTANT(opline->op2)); + ZVAL_COPY(param, EX_CONSTANT(opline->op2)); if (Z_OPT_CONSTANT_P(param)) { SAVE_OPLINE(); - if (UNEXPECTED(zval_update_constant_ex(param, 0, NULL) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(param, EX(func)->op_array.scope) != SUCCESS)) { ZVAL_UNDEF(param); HANDLE_EXCEPTION(); } - } else { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(param))) { - Z_ADDREF_P(param); - } } } @@ -2589,7 +2252,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(Z zval *default_value = EX_CONSTANT(opline->op2); SAVE_OPLINE(); - if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, default_value, CACHE_ADDR(Z_CACHE_SLOT_P(default_value))))) { + if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, default_value, CACHE_ADDR(Z_CACHE_SLOT_P(default_value))) || EG(exception))) { HANDLE_EXCEPTION(); } } @@ -2752,195 +2415,21 @@ try_class_name: static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_function *fbc; - zval *function_name, *func; - zend_string *lcname; - zend_class_entry *called_scope; - zend_object *object; + zval *function_name; zend_execute_data *call; - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION; SAVE_OPLINE(); function_name = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); try_function_name: if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - const char *colon; - - if ((colon = zend_memrchr(Z_STRVAL_P(function_name), ':', Z_STRLEN_P(function_name))) != NULL && - colon > Z_STRVAL_P(function_name) && - *(colon-1) == ':' - ) { - zend_string *mname; - size_t cname_length = colon - Z_STRVAL_P(function_name) - 1; - size_t mname_length = Z_STRLEN_P(function_name) - cname_length - (sizeof("::") - 1); - - lcname = zend_string_init(Z_STRVAL_P(function_name), cname_length, 0); - - object = NULL; - called_scope = zend_fetch_class_by_name(lcname, NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(called_scope == NULL)) { - zend_string_release(lcname); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - mname = zend_string_init(Z_STRVAL_P(function_name) + (cname_length + sizeof("::") - 1), mname_length, 0); - - if (called_scope->get_static_method) { - fbc = called_scope->get_static_method(called_scope, mname); - } else { - fbc = zend_std_get_static_method(called_scope, mname, NULL); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), ZSTR_VAL(mname)); - } - zend_string_release(lcname); - zend_string_release(mname); - - HANDLE_EXCEPTION(); - } - - zend_string_release(lcname); - zend_string_release(mname); - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - - HANDLE_EXCEPTION(); - } - } - } else { - if (Z_STRVAL_P(function_name)[0] == '\\') { - lcname = zend_string_alloc(Z_STRLEN_P(function_name) - 1, 0); - zend_str_tolower_copy(ZSTR_VAL(lcname), 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)) { - zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name)); - zend_string_release(lcname); - - HANDLE_EXCEPTION(); - } - zend_string_release(lcname); - - fbc = Z_FUNC_P(func); - called_scope = NULL; - object = NULL; - } - - } else if (IS_CV != 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 (fbc->common.fn_flags & ZEND_ACC_CLOSURE) { - /* Delay closure destruction until its invocation */ - ZEND_ASSERT(GC_TYPE((zend_object*)fbc->common.prototype) == IS_OBJECT); - GC_REFCOUNT((zend_object*)fbc->common.prototype)++; - call_info |= ZEND_CALL_CLOSURE; - } else if (object) { - call_info |= ZEND_CALL_RELEASE_THIS; - GC_REFCOUNT(object)++; /* For $this pointer */ - } - - } 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); - - if (!obj || !method) { - zend_throw_error(NULL, "Array callback has to contain indices 0 and 1"); - - HANDLE_EXCEPTION(); - } - - ZVAL_DEREF(obj); - if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) { - zend_throw_error(NULL, "First array member is not a valid class name or object"); - - HANDLE_EXCEPTION(); - } - - ZVAL_DEREF(method); - if (Z_TYPE_P(method) != IS_STRING) { - zend_throw_error(NULL, "Second array member is not a valid method"); - - HANDLE_EXCEPTION(); - } - - if (Z_TYPE_P(obj) == IS_STRING) { - object = NULL; - called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(called_scope == NULL)) { - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - 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); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), Z_STRVAL_P(method)); - } - - HANDLE_EXCEPTION(); - } - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - - HANDLE_EXCEPTION(); - } - } - } else { - 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)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(object->ce->name), Z_STRVAL_P(method)); - } - - HANDLE_EXCEPTION(); - } - - if ((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { - object = NULL; - } else { - call_info |= ZEND_CALL_RELEASE_THIS; - GC_REFCOUNT(object)++; /* For $this pointer */ - } - } - - } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(function_name) == IS_REFERENCE) { + call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value); + } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) { + call = zend_init_dynamic_call_object(function_name, opline->extended_value); + } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) { + call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value); + } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) { function_name = Z_REFVAL_P(function_name); goto try_function_name; } else { @@ -2951,14 +2440,13 @@ try_function_name: } } zend_throw_error(NULL, "Function name must be a string"); + call = NULL; + } + if (UNEXPECTED(!call)) { HANDLE_EXCEPTION(); } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) { - init_func_run_time_cache(&fbc->op_array); - } - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, called_scope, object); + call->prev_execute_data = EX(call); EX(call) = call; @@ -3011,195 +2499,21 @@ try_class_name: static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { 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; + zval *function_name; zend_execute_data *call; - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION; SAVE_OPLINE(); function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); try_function_name: if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - const char *colon; - - if ((colon = zend_memrchr(Z_STRVAL_P(function_name), ':', Z_STRLEN_P(function_name))) != NULL && - colon > Z_STRVAL_P(function_name) && - *(colon-1) == ':' - ) { - zend_string *mname; - size_t cname_length = colon - Z_STRVAL_P(function_name) - 1; - size_t mname_length = Z_STRLEN_P(function_name) - cname_length - (sizeof("::") - 1); - - lcname = zend_string_init(Z_STRVAL_P(function_name), cname_length, 0); - - object = NULL; - called_scope = zend_fetch_class_by_name(lcname, NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(called_scope == NULL)) { - zend_string_release(lcname); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - mname = zend_string_init(Z_STRVAL_P(function_name) + (cname_length + sizeof("::") - 1), mname_length, 0); - - if (called_scope->get_static_method) { - fbc = called_scope->get_static_method(called_scope, mname); - } else { - fbc = zend_std_get_static_method(called_scope, mname, NULL); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), ZSTR_VAL(mname)); - } - zend_string_release(lcname); - zend_string_release(mname); - zval_ptr_dtor_nogc(free_op2); - HANDLE_EXCEPTION(); - } - - zend_string_release(lcname); - zend_string_release(mname); - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - zval_ptr_dtor_nogc(free_op2); - HANDLE_EXCEPTION(); - } - } - } else { - if (Z_STRVAL_P(function_name)[0] == '\\') { - lcname = zend_string_alloc(Z_STRLEN_P(function_name) - 1, 0); - zend_str_tolower_copy(ZSTR_VAL(lcname), 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)) { - zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name)); - zend_string_release(lcname); - zval_ptr_dtor_nogc(free_op2); - HANDLE_EXCEPTION(); - } - zend_string_release(lcname); - - fbc = Z_FUNC_P(func); - called_scope = NULL; - object = NULL; - } - zval_ptr_dtor_nogc(free_op2); - } else if ((IS_TMP_VAR|IS_VAR) != 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 (fbc->common.fn_flags & ZEND_ACC_CLOSURE) { - /* Delay closure destruction until its invocation */ - ZEND_ASSERT(GC_TYPE((zend_object*)fbc->common.prototype) == IS_OBJECT); - GC_REFCOUNT((zend_object*)fbc->common.prototype)++; - call_info |= ZEND_CALL_CLOSURE; - } else if (object) { - call_info |= ZEND_CALL_RELEASE_THIS; - GC_REFCOUNT(object)++; /* For $this pointer */ - } - zval_ptr_dtor_nogc(free_op2); - } 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); - - if (!obj || !method) { - zend_throw_error(NULL, "Array callback has to contain indices 0 and 1"); - zval_ptr_dtor_nogc(free_op2); - HANDLE_EXCEPTION(); - } - - ZVAL_DEREF(obj); - if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) { - zend_throw_error(NULL, "First array member is not a valid class name or object"); - zval_ptr_dtor_nogc(free_op2); - HANDLE_EXCEPTION(); - } - - ZVAL_DEREF(method); - if (Z_TYPE_P(method) != IS_STRING) { - zend_throw_error(NULL, "Second array member is not a valid method"); - zval_ptr_dtor_nogc(free_op2); - HANDLE_EXCEPTION(); - } - - if (Z_TYPE_P(obj) == IS_STRING) { - object = NULL; - called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(called_scope == NULL)) { - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - 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); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), Z_STRVAL_P(method)); - } - zval_ptr_dtor_nogc(free_op2); - HANDLE_EXCEPTION(); - } - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - zval_ptr_dtor_nogc(free_op2); - HANDLE_EXCEPTION(); - } - } - } else { - 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)) { - if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(object->ce->name), Z_STRVAL_P(method)); - } - zval_ptr_dtor_nogc(free_op2); - HANDLE_EXCEPTION(); - } - - if ((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { - object = NULL; - } else { - call_info |= ZEND_CALL_RELEASE_THIS; - GC_REFCOUNT(object)++; /* For $this pointer */ - } - } - zval_ptr_dtor_nogc(free_op2); - } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(function_name) == IS_REFERENCE) { + call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value); + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) { + call = zend_init_dynamic_call_object(function_name, opline->extended_value); + } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) { + call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value); + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) { function_name = Z_REFVAL_P(function_name); goto try_function_name; } else { @@ -3210,14 +2524,15 @@ try_function_name: } } zend_throw_error(NULL, "Function name must be a string"); - zval_ptr_dtor_nogc(free_op2); - HANDLE_EXCEPTION(); + call = NULL; } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) { - init_func_run_time_cache(&fbc->op_array); + + zval_ptr_dtor_nogc(free_op2); + + if (UNEXPECTED(!call)) { + HANDLE_EXCEPTION(); } - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, called_scope, object); + call->prev_execute_data = EX(call); EX(call) = call; @@ -3560,14 +2875,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDL retval_ptr = EX_CONSTANT(opline->op1); if (!EX(return_value)) { - if (IS_CONST == IS_TMP_VAR) { - } } else { - ZVAL_COPY_VALUE(EX(return_value), retval_ptr); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; - if (IS_CONST != IS_TMP_VAR) { - zval_opt_copy_ctor_no_imm(EX(return_value)); + if (IS_CONST == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); + break; + } + + ZVAL_NEW_REF(EX(return_value), retval_ptr); + if (IS_CONST == IS_CONST) { + if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); } } break; @@ -3577,13 +2894,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDL if (IS_CONST == IS_VAR) { if (retval_ptr == &EG(uninitialized_zval) || - (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF))) { + (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr))) { zend_error(E_NOTICE, "Only variable references should be returned by reference"); if (EX(return_value)) { ZVAL_NEW_REF(EX(return_value), retval_ptr); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; - if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); + } else { + } break; } @@ -3593,8 +2909,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDL ZVAL_MAKE_REF(retval_ptr); Z_ADDREF_P(retval_ptr); ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr)); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; } + } while (0); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); @@ -3858,7 +3174,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_ USE_OPLINE zval *obj; - zend_class_entry *ce; + zend_class_entry *ce, *scope; zend_function *clone; zend_object_clone_obj_t clone_call; @@ -3904,16 +3220,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_ if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) { /* Ensure that if we're calling a private function, we're allowed to do so. */ - if (UNEXPECTED(ce != EG(scope))) { - zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = EX(func)->op_array.scope; + if (UNEXPECTED(ce != scope)) { + zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), scope ? ZSTR_VAL(scope->name) : ""); HANDLE_EXCEPTION(); } } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ - if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { - zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = EX(func)->op_array.scope; + if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) { + zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), scope ? ZSTR_VAL(scope->name) : ""); HANDLE_EXCEPTION(); } @@ -4031,89 +3349,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_O static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_op_array *new_op_array=NULL; + zend_op_array *new_op_array; zval *inc_filename; - zval tmp_inc_filename; - zend_bool failure_retval=0; SAVE_OPLINE(); inc_filename = EX_CONSTANT(opline->op1); - - ZVAL_UNDEF(&tmp_inc_filename); - if (Z_TYPE_P(inc_filename) != IS_STRING) { - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(inc_filename) == IS_UNDEF)) { - inc_filename = GET_OP1_UNDEF_CV(inc_filename, BP_VAR_R); - } - ZVAL_STR(&tmp_inc_filename, zval_get_string(inc_filename)); - inc_filename = &tmp_inc_filename; - } - - if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { - if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { - zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename)); - } else { - zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename)); - } - } else { - switch (opline->extended_value) { - case ZEND_INCLUDE_ONCE: - case ZEND_REQUIRE_ONCE: { - zend_file_handle file_handle; - zend_string *resolved_path; - - resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), (int)Z_STRLEN_P(inc_filename)); - if (resolved_path) { - failure_retval = zend_hash_exists(&EG(included_files), resolved_path); - } else { - resolved_path = zend_string_copy(Z_STR_P(inc_filename)); - } - - if (failure_retval) { - /* do nothing, file already included */ - } else if (SUCCESS == zend_stream_open(ZSTR_VAL(resolved_path), &file_handle)) { - - if (!file_handle.opened_path) { - file_handle.opened_path = zend_string_copy(resolved_path); - } - - if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path)) { - new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE)); - zend_destroy_file_handle(&file_handle); - } else { - zend_file_handle_dtor(&file_handle); - failure_retval=1; - } - } else { - if (opline->extended_value == ZEND_INCLUDE_ONCE) { - zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename)); - } else { - zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename)); - } - } - zend_string_release(resolved_path); - } - break; - case ZEND_INCLUDE: - case ZEND_REQUIRE: - new_op_array = compile_filename(opline->extended_value, inc_filename); - break; - case ZEND_EVAL: { - char *eval_desc = zend_make_compiled_string_description("eval()'d code"); - - new_op_array = zend_compile_string(inc_filename, eval_desc); - efree(eval_desc); - } - break; - EMPTY_SWITCH_DEFAULT_CASE() - } - } - if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) { - zend_string_release(Z_STR(tmp_inc_filename)); - } + new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); + } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + } } else if (EXPECTED(new_op_array != NULL)) { zval *return_value = NULL; zend_execute_data *call; @@ -4122,21 +3371,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN return_value = EX_VAR(opline->result.var); } - new_op_array->scope = EG(scope); + new_op_array->scope = EX(func)->op_array.scope; - call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE, + call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, (zend_function*)new_op_array, 0, Z_TYPE(EX(This)) != IS_OBJECT ? Z_CE(EX(This)) : NULL, Z_TYPE(EX(This)) == IS_OBJECT ? Z_OBJ(EX(This)) : NULL); - if (EX(symbol_table)) { + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { call->symbol_table = EX(symbol_table); } else { call->symbol_table = zend_rebuild_symbol_table(); } call->prev_execute_data = execute_data; - i_init_code_execute_data(call, new_op_array, return_value); + i_init_code_execute_data(call, new_op_array, return_value); if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -4151,12 +3400,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN zend_throw_exception_internal(NULL); HANDLE_EXCEPTION(); } - } else if (RETURN_VALUE_USED(opline)) { - ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval); + ZVAL_FALSE(EX_VAR(opline->result.var)); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -4480,9 +3728,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEN } else if (IS_CONST == IS_VAR && ref) { zend_reference *r = Z_REF_P(ref); - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) { efree_size(r, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); } } ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); @@ -4519,9 +3768,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CONST_HANDLER(ZE } else if (IS_CONST == IS_VAR && ref) { zend_reference *r = Z_REF_P(ref); - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) { efree_size(r, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); } } ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); @@ -4535,30 +3785,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(Z USE_OPLINE zval *value; + zval *result = EX_VAR(opline->result.var); value = EX_CONSTANT(opline->op1); if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { SAVE_OPLINE(); GET_OP1_UNDEF_CV(value, BP_VAR_R); - ZVAL_NULL(EX_VAR(opline->result.var)); + ZVAL_NULL(result); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && Z_ISREF_P(value)) { - ZVAL_COPY(EX_VAR(opline->result.var), Z_REFVAL_P(value)); - if (IS_CONST == IS_VAR) { + if (IS_CONST == IS_CV) { + ZVAL_DEREF(value); + ZVAL_COPY(result, value); + } else if (IS_CONST == IS_VAR) { + if (UNEXPECTED(Z_ISREF_P(value))) { + ZVAL_COPY_VALUE(result, Z_REFVAL_P(value)); if (UNEXPECTED(Z_DELREF_P(value) == 0)) { efree_size(Z_REF_P(value), sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); } + } else { + ZVAL_COPY_VALUE(result, value); } } else { - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); + ZVAL_COPY_VALUE(result, value); if (IS_CONST == IS_CONST) { if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) { - zval_copy_ctor_func(EX_VAR(opline->result.var)); + zval_copy_ctor_func(result); } - } else if (IS_CONST == IS_CV) { - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); } } ZEND_VM_NEXT_OPCODE(); @@ -5800,93 +5056,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CONST_CONST_HA { USE_OPLINE - zval *container; - zval *offset = EX_CONSTANT(opline->op2); SAVE_OPLINE(); container = EX_CONSTANT(opline->op1); - -try_fetch_list: - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value; - zend_string *str; - zend_ulong hval; - -assign_again_list: - if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_list: - value = zend_hash_index_find(Z_ARRVAL_P(container), hval); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined offset: " ZEND_ULONG_FMT, hval); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_list; - } - -str_index_list: - value = zend_hash_find(Z_ARRVAL_P(container), str); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(str)); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (UNEXPECTED(str != Z_STR_P(offset))) { - zend_string_release(str); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto assign_again_list; - } else if (Z_TYPE_P(offset) == IS_NULL) { - str = ZSTR_EMPTY_ALLOC(); - goto str_index_list; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(offset), Z_RES_HANDLE_P(offset)); - hval = Z_RES_HANDLE_P(offset); - } else { - zend_error(E_WARNING, "Illegal offset type"); - } - } else if (IS_CONST != IS_CONST && - UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && - EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { - zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, offset, BP_VAR_R, result); - - if (retval) { - if (result != retval) { - ZVAL_COPY(result, retval); - } - } else { - ZVAL_NULL(result); - } - } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) { - container = Z_REFVAL_P(container); - goto try_fetch_list; - } else { - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - GET_OP1_UNDEF_CV(container, BP_VAR_R); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - } + zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -6374,7 +5548,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CONST_HANDLER( static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - zend_class_entry *ce; + zend_class_entry *ce, *scope; zend_class_constant *c; zval *value; USE_OPLINE @@ -6417,15 +5591,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS } if (EXPECTED((c = zend_hash_find_ptr(&ce->constants_table, Z_STR_P(EX_CONSTANT(opline->op2)))) != NULL)) { - if (!zend_verify_const_access(c, EG(scope))) { + scope = EX(func)->op_array.scope; + if (!zend_verify_const_access(c, scope)) { zend_throw_error(NULL, "Cannot access %s const %s::%s", zend_visibility_string(Z_ACCESS_FLAGS(c->value)), ZSTR_VAL(ce->name), Z_STRVAL_P(EX_CONSTANT(opline->op2))); HANDLE_EXCEPTION(); } value = &c->value; if (Z_CONSTANT_P(value)) { - EG(scope) = ce; - zval_update_constant_ex(value, 1, NULL); - EG(scope) = EX(func)->op_array.scope; + zval_update_constant_ex(value, ce); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } @@ -6918,17 +6091,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST name = EX_CONSTANT(opline->op1); val = EX_CONSTANT(opline->op2); - ZVAL_COPY_VALUE(&c.value, val); + ZVAL_COPY(&c.value, val); if (Z_OPT_CONSTANT(c.value)) { - if (UNEXPECTED(zval_update_constant_ex(&c.value, 0, NULL) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) { HANDLE_EXCEPTION(); } - } else { - if (UNEXPECTED(Z_OPT_REFCOUNTED(c.value))) { - Z_ADDREF(c.value); - } } c.flags = CONST_CS; /* non persistent, case sensetive */ c.name = zend_string_dup(Z_STR_P(name), 0); @@ -6988,7 +6157,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER if (IS_CONST == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -7159,7 +6328,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(Z if (IS_CONST == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -7610,7 +6779,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(Z if (IS_CONST == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -8613,7 +7782,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_C object = NULL; } zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), - EG(scope), called_scope, object); + EX(func)->op_array.scope, called_scope, object); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -8665,7 +7834,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLE if (IS_CONST == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -9398,7 +8567,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HAND SAVE_OPLINE(); container = EX_CONSTANT(opline->op1); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -9412,7 +8581,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HAN SAVE_OPLINE(); container = EX_CONSTANT(opline->op1); - zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -9434,7 +8603,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_ HANDLE_EXCEPTION(); } container = NULL; - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } @@ -9448,7 +8617,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_ HANDLE_EXCEPTION(); } container = EX_CONSTANT(opline->op1); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); } @@ -9640,93 +8809,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CONST_CV_HANDL { USE_OPLINE - zval *container; - zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); SAVE_OPLINE(); container = EX_CONSTANT(opline->op1); - -try_fetch_list: - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value; - zend_string *str; - zend_ulong hval; - -assign_again_list: - if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_list: - value = zend_hash_index_find(Z_ARRVAL_P(container), hval); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined offset: " ZEND_ULONG_FMT, hval); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_list; - } - -str_index_list: - value = zend_hash_find(Z_ARRVAL_P(container), str); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(str)); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (UNEXPECTED(str != Z_STR_P(offset))) { - zend_string_release(str); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto assign_again_list; - } else if (Z_TYPE_P(offset) == IS_NULL) { - str = ZSTR_EMPTY_ALLOC(); - goto str_index_list; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(offset), Z_RES_HANDLE_P(offset)); - hval = Z_RES_HANDLE_P(offset); - } else { - zend_error(E_WARNING, "Illegal offset type"); - } - } else if (IS_CONST != IS_CONST && - UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && - EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { - zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, offset, BP_VAR_R, result); - - if (retval) { - if (result != retval) { - ZVAL_COPY(result, retval); - } - } else { - ZVAL_NULL(result); - } - } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) { - container = Z_REFVAL_P(container); - goto try_fetch_list; - } else { - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - GET_OP1_UNDEF_CV(container, BP_VAR_R); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - } + zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -10620,7 +9707,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE if (IS_CONST == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -11560,94 +10647,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op2; zval *container; - zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); SAVE_OPLINE(); container = EX_CONSTANT(opline->op1); - -try_fetch_list: - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value; - zend_string *str; - zend_ulong hval; - -assign_again_list: - if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_list: - value = zend_hash_index_find(Z_ARRVAL_P(container), hval); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined offset: " ZEND_ULONG_FMT, hval); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_list; - } - -str_index_list: - value = zend_hash_find(Z_ARRVAL_P(container), str); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(str)); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (UNEXPECTED(str != Z_STR_P(offset))) { - zend_string_release(str); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto assign_again_list; - } else if (Z_TYPE_P(offset) == IS_NULL) { - str = ZSTR_EMPTY_ALLOC(); - goto str_index_list; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(offset), Z_RES_HANDLE_P(offset)); - hval = Z_RES_HANDLE_P(offset); - } else { - zend_error(E_WARNING, "Illegal offset type"); - } - } else if (IS_CONST != IS_CONST && - UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && - EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { - zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, offset, BP_VAR_R, result); - - if (retval) { - if (result != retval) { - ZVAL_COPY(result, retval); - } - } else { - ZVAL_NULL(result); - } - } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) { - container = Z_REFVAL_P(container); - goto try_fetch_list; - } else { - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - GET_OP1_UNDEF_CV(container, BP_VAR_R); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - } + zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)); zval_ptr_dtor_nogc(free_op2); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -12974,14 +11979,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1); if (!EX(return_value)) { - if (IS_TMP_VAR == IS_TMP_VAR) { - zval_ptr_dtor_nogc(free_op1); - } + zval_ptr_dtor_nogc(free_op1); } else { - ZVAL_COPY_VALUE(EX(return_value), retval_ptr); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; - if (IS_TMP_VAR != IS_TMP_VAR) { - zval_opt_copy_ctor_no_imm(EX(return_value)); + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); + break; + } + + ZVAL_NEW_REF(EX(return_value), retval_ptr); + if (IS_TMP_VAR == IS_CONST) { + if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); } } break; @@ -12991,13 +11998,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER if (IS_TMP_VAR == IS_VAR) { if (retval_ptr == &EG(uninitialized_zval) || - (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF))) { + (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr))) { zend_error(E_NOTICE, "Only variable references should be returned by reference"); if (EX(return_value)) { ZVAL_NEW_REF(EX(return_value), retval_ptr); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; - if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); + } else { + } break; } @@ -13007,8 +12013,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER ZVAL_MAKE_REF(retval_ptr); Z_ADDREF_P(retval_ptr); ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr)); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; } + } while (0); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); @@ -13582,9 +12588,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_ } else if (IS_TMP_VAR == IS_VAR && ref) { zend_reference *r = Z_REF_P(ref); - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) { efree_size(r, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); } } ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); @@ -13622,9 +12629,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND } else if (IS_TMP_VAR == IS_VAR && ref) { zend_reference *r = Z_REF_P(ref); - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) { efree_size(r, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); } } ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); @@ -13639,30 +12647,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEN USE_OPLINE zend_free_op free_op1; zval *value; + zval *result = EX_VAR(opline->result.var); value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1); if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { SAVE_OPLINE(); GET_OP1_UNDEF_CV(value, BP_VAR_R); - ZVAL_NULL(EX_VAR(opline->result.var)); + ZVAL_NULL(result); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) { - ZVAL_COPY(EX_VAR(opline->result.var), Z_REFVAL_P(value)); - if (IS_TMP_VAR == IS_VAR) { + if (IS_TMP_VAR == IS_CV) { + ZVAL_DEREF(value); + ZVAL_COPY(result, value); + } else if (IS_TMP_VAR == IS_VAR) { + if (UNEXPECTED(Z_ISREF_P(value))) { + ZVAL_COPY_VALUE(result, Z_REFVAL_P(value)); if (UNEXPECTED(Z_DELREF_P(value) == 0)) { efree_size(Z_REF_P(value), sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); } + } else { + ZVAL_COPY_VALUE(result, value); } } else { - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); + ZVAL_COPY_VALUE(result, value); if (IS_TMP_VAR == IS_CONST) { if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) { - zval_copy_ctor_func(EX_VAR(opline->result.var)); + zval_copy_ctor_func(result); } - } else if (IS_TMP_VAR == IS_CV) { - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); } } ZEND_VM_NEXT_OPCODE(); @@ -14235,7 +13249,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(Z if (IS_TMP_VAR == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -14406,7 +13420,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEN if (IS_TMP_VAR == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -14577,7 +13591,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEN if (IS_TMP_VAR == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -14929,7 +13943,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER( if (IS_TMP_VAR == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -15069,7 +14083,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV HANDLE_EXCEPTION(); } container = NULL; - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } @@ -15083,7 +14097,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV HANDLE_EXCEPTION(); } container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); zval_ptr_dtor_nogc(free_op1); } @@ -15457,7 +14471,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND if (IS_TMP_VAR == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -16241,14 +15255,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); if (!EX(return_value)) { - if (IS_VAR == IS_TMP_VAR) { - zval_ptr_dtor_nogc(free_op1); - } + zval_ptr_dtor_nogc(free_op1); } else { - ZVAL_COPY_VALUE(EX(return_value), retval_ptr); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; - if (IS_VAR != IS_TMP_VAR) { - zval_opt_copy_ctor_no_imm(EX(return_value)); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); + break; + } + + ZVAL_NEW_REF(EX(return_value), retval_ptr); + if (IS_VAR == IS_CONST) { + if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); } } break; @@ -16258,13 +15274,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER if (IS_VAR == IS_VAR) { if (retval_ptr == &EG(uninitialized_zval) || - (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF))) { + (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr))) { zend_error(E_NOTICE, "Only variable references should be returned by reference"); if (EX(return_value)) { ZVAL_NEW_REF(EX(return_value), retval_ptr); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; - if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); + } else { + if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; } break; } @@ -16274,11 +15289,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER ZVAL_MAKE_REF(retval_ptr); Z_ADDREF_P(retval_ptr); ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr)); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; } + + if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; } while (0); - if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -16420,27 +15435,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDL varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) || - (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) && - (Z_ISREF_P(varptr) || Z_TYPE_P(varptr) == IS_OBJECT)) { + if (EXPECTED(Z_ISREF_P(varptr) || + ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ? + ((opline->extended_value & ZEND_ARG_SEND_SILENT) != 0) : + ARG_MAY_BE_SENT_BY_REF(EX(call)->func, opline->op2.num + )))) { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_COPY_VALUE(arg, varptr); - ZVAL_MAKE_REF(varptr); - } else { - if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ? - !(opline->extended_value & ZEND_ARG_SEND_SILENT) : - !ARG_MAY_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) { - SAVE_OPLINE(); - zend_error(E_NOTICE, "Only variables should be passed by reference"); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, varptr); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } + ZEND_VM_NEXT_OPCODE(); } + SAVE_OPLINE(); + zend_error(E_NOTICE, "Only variables should be passed by reference"); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); ZVAL_COPY_VALUE(arg, varptr); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16581,7 +15593,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEN if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) { if (UNEXPECTED(!Z_ISREF_P(arg))) { - 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", @@ -16599,26 +15610,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEN ZVAL_UNDEF(param); EX(call)->func = (zend_function*)&zend_pass_function; Z_OBJ(EX(call)->This) = NULL; - ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call))); + ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call)) & ~ZEND_CALL_RELEASE_THIS); zval_ptr_dtor_nogc(free_op1); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - - ZVAL_NEW_REF(arg, arg); } - Z_ADDREF_P(arg); } else { if (Z_ISREF_P(arg) && !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) { /* don't separate references for __call */ arg = Z_REFVAL_P(arg); } - if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } } - ZVAL_COPY_VALUE(param, arg); + ZVAL_COPY(param, arg); zval_ptr_dtor_nogc(free_op1); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -17457,9 +16462,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_ } else if (IS_VAR == IS_VAR && ref) { zend_reference *r = Z_REF_P(ref); - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) { efree_size(r, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); } } ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); @@ -17497,9 +16503,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND } else if (IS_VAR == IS_VAR && ref) { zend_reference *r = Z_REF_P(ref); - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) { efree_size(r, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); } } ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); @@ -17514,30 +16521,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEN USE_OPLINE zend_free_op free_op1; zval *value; + zval *result = EX_VAR(opline->result.var); value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { SAVE_OPLINE(); GET_OP1_UNDEF_CV(value, BP_VAR_R); - ZVAL_NULL(EX_VAR(opline->result.var)); + ZVAL_NULL(result); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) { - ZVAL_COPY(EX_VAR(opline->result.var), Z_REFVAL_P(value)); - if (IS_VAR == IS_VAR) { + if (IS_VAR == IS_CV) { + ZVAL_DEREF(value); + ZVAL_COPY(result, value); + } else if (IS_VAR == IS_VAR) { + if (UNEXPECTED(Z_ISREF_P(value))) { + ZVAL_COPY_VALUE(result, Z_REFVAL_P(value)); if (UNEXPECTED(Z_DELREF_P(value) == 0)) { efree_size(Z_REF_P(value), sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); } + } else { + ZVAL_COPY_VALUE(result, value); } } else { - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); + ZVAL_COPY_VALUE(result, value); if (IS_VAR == IS_CONST) { if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) { - zval_copy_ctor_func(EX_VAR(opline->result.var)); + zval_copy_ctor_func(result); } - } else if (IS_VAR == IS_CV) { - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); } } ZEND_VM_NEXT_OPCODE(); @@ -17775,7 +16788,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op1, free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); @@ -17787,40 +16800,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = EX_CONSTANT(opline->op2); + if (IS_VAR != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if (IS_CONST == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = EX_CONSTANT(opline->op2); - do { - if (IS_VAR == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_VAR != IS_UNUSED) { - ZVAL_DEREF(container); + if (IS_CONST == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, IS_CONST); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_VAR != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = EX_CONSTANT(opline->op2); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_VAR != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if (IS_CONST == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } FREE_OP(free_op_data1); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; @@ -19224,31 +18284,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == 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 = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((opline+1)->op1); - value = zend_assign_to_variable(variable_ptr, value, IS_CONST); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = EX_CONSTANT((opline+1)->op1); + value = zend_assign_to_variable(variable_ptr, value, IS_CONST); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -19257,11 +18315,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = EX_CONSTANT((opline+1)->op1); + + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = EX_CONSTANT(opline->op2); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CONST == IS_UNUSED) { @@ -19270,13 +18341,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -19288,18 +18355,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = EX_CONSTANT(opline->op2); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CONST != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -19320,31 +18390,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == 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 = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -19353,11 +18421,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = EX_CONSTANT(opline->op2); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CONST == IS_UNUSED) { @@ -19366,13 +18447,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -19384,18 +18461,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = EX_CONSTANT(opline->op2); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CONST != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -19416,31 +18496,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == 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 = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -19449,11 +18527,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - zval *property_name = EX_CONSTANT(opline->op2); + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + zend_assign_to_object_dim(object_ptr, dim, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CONST == IS_UNUSED) { @@ -19462,13 +18553,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -19480,18 +18567,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = EX_CONSTANT(opline->op2); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CONST != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -19512,31 +18602,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == 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 = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -19545,11 +18633,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = EX_CONSTANT(opline->op2); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CONST == IS_UNUSED) { @@ -19558,13 +18659,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -19576,18 +18673,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = EX_CONSTANT(opline->op2); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CONST != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -19809,7 +18909,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - zend_class_entry *ce; + zend_class_entry *ce, *scope; zend_class_constant *c; zval *value; USE_OPLINE @@ -19852,15 +18952,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ } if (EXPECTED((c = zend_hash_find_ptr(&ce->constants_table, Z_STR_P(EX_CONSTANT(opline->op2)))) != NULL)) { - if (!zend_verify_const_access(c, EG(scope))) { + scope = EX(func)->op_array.scope; + if (!zend_verify_const_access(c, scope)) { zend_throw_error(NULL, "Cannot access %s const %s::%s", zend_visibility_string(Z_ACCESS_FLAGS(c->value)), ZSTR_VAL(ce->name), Z_STRVAL_P(EX_CONSTANT(opline->op2))); HANDLE_EXCEPTION(); } value = &c->value; if (Z_CONSTANT_P(value)) { - EG(scope) = ce; - zval_update_constant_ex(value, 1, NULL); - EG(scope) = EX(func)->op_array.scope; + zval_update_constant_ex(value, ce); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } @@ -20089,6 +19188,9 @@ num_index_dim: goto unset_dim_array; } } + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_R); + } if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R); } @@ -20192,7 +19294,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z if (IS_VAR == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -20420,7 +19522,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEN if (IS_VAR == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -20623,8 +19725,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLE } else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_FUNCTION && - UNEXPECTED(!(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { - + UNEXPECTED(!Z_ISREF_P(value_ptr))) { zend_error(E_NOTICE, "Only variables should be assigned by reference"); if (UNEXPECTED(EG(exception) != NULL)) { if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);}; @@ -20704,7 +19805,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN if (IS_VAR == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -20797,7 +19898,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op1, free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); @@ -20809,40 +19910,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = NULL; + if (IS_VAR != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if (IS_UNUSED == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = NULL; - do { - if (IS_VAR == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_VAR != IS_UNUSED) { - ZVAL_DEREF(container); + if (IS_UNUSED == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, IS_UNUSED); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_VAR != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = NULL; - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_VAR != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if (IS_UNUSED == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } FREE_OP(free_op_data1); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; @@ -21177,31 +20325,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == 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 = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((opline+1)->op1); - value = zend_assign_to_variable(variable_ptr, value, IS_CONST); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = EX_CONSTANT((opline+1)->op1); + value = zend_assign_to_variable(variable_ptr, value, IS_CONST); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -21210,11 +20356,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = EX_CONSTANT((opline+1)->op1); - zval *property_name = NULL; + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_UNUSED == IS_UNUSED) { @@ -21223,13 +20382,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -21241,18 +20396,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = NULL; +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_UNUSED != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -21273,31 +20431,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == 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 = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -21306,11 +20462,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = NULL; + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_UNUSED == IS_UNUSED) { @@ -21319,13 +20488,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -21337,18 +20502,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = NULL; +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_UNUSED != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -21369,31 +20537,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == 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 = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -21402,11 +20568,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - zval *property_name = NULL; + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + zend_assign_to_object_dim(object_ptr, dim, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_UNUSED == IS_UNUSED) { @@ -21415,13 +20594,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -21433,18 +20608,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = NULL; +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_UNUSED != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -21465,31 +20643,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == 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 = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -21498,11 +20674,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = NULL; + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_UNUSED == IS_UNUSED) { @@ -21511,13 +20700,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -21529,18 +20714,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = NULL; +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_UNUSED != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -21894,10 +21082,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDL if (UNEXPECTED(Z_REFCOUNT_P(var_ptr) == 1)) { ZVAL_UNREF(var_ptr); } - } else if (Z_COPYABLE_P(var_ptr) && Z_REFCOUNT_P(var_ptr) > 1) { - Z_DELREF_P(var_ptr); - ZVAL_DUP(EX_VAR(opline->op1.var), var_ptr); } + ZEND_VM_NEXT_OPCODE(); } @@ -21948,7 +21134,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER( if (IS_VAR == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -22140,7 +21326,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op1, free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); @@ -22152,40 +21338,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_VAR != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if (IS_CV == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); - do { - if (IS_VAR == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_VAR != IS_UNUSED) { - ZVAL_DEREF(container); + if (IS_CV == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_VAR != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_VAR != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if (IS_CV == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } FREE_OP(free_op_data1); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; @@ -22622,7 +21855,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLE SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -22640,7 +21873,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDL SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -22665,7 +21898,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV HANDLE_EXCEPTION(); } container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } @@ -22679,7 +21912,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV HANDLE_EXCEPTION(); } container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); zval_ptr_dtor_nogc(free_op1); } @@ -22695,7 +21928,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HA SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -23589,31 +22822,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == 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 = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((opline+1)->op1); - value = zend_assign_to_variable(variable_ptr, value, IS_CONST); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = EX_CONSTANT((opline+1)->op1); + value = zend_assign_to_variable(variable_ptr, value, IS_CONST); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -23622,11 +22853,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = EX_CONSTANT((opline+1)->op1); + + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CV == IS_UNUSED) { @@ -23635,13 +22879,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -23653,18 +22893,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CV != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -23685,31 +22928,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == 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 = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -23718,11 +22959,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CV == IS_UNUSED) { @@ -23731,13 +22985,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -23749,18 +22999,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CV != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -23781,31 +23034,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == 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 = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -23814,11 +23065,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + zend_assign_to_object_dim(object_ptr, dim, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CV == IS_UNUSED) { @@ -23827,13 +23091,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -23845,18 +23105,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CV != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -23877,31 +23140,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == 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 = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -23910,11 +23171,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CV == IS_UNUSED) { @@ -23923,13 +23197,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -23941,18 +23211,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CV != IS_UNUSED) { + + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -24036,8 +23309,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER } else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_FUNCTION && - UNEXPECTED(!(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { - + UNEXPECTED(!Z_ISREF_P(value_ptr))) { zend_error(E_NOTICE, "Only variables should be assigned by reference"); if (UNEXPECTED(EG(exception) != NULL)) { @@ -24427,6 +23699,9 @@ num_index_dim: goto unset_dim_array; } } + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_R); + } if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R); } @@ -24530,7 +23805,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND if (IS_VAR == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -24686,7 +23961,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op1, free_op2, free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); @@ -24698,40 +23973,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + if (IS_VAR != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - do { - if (IS_VAR == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_VAR != IS_UNUSED) { - ZVAL_DEREF(container); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, (IS_TMP_VAR|IS_VAR)); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_VAR != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_VAR != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } zval_ptr_dtor_nogc(free_op2); FREE_OP(free_op_data1); @@ -26140,31 +25462,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == 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 = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((opline+1)->op1); - value = zend_assign_to_variable(variable_ptr, value, IS_CONST); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = EX_CONSTANT((opline+1)->op1); + value = zend_assign_to_variable(variable_ptr, value, IS_CONST); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -26173,11 +25493,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_free_op free_op2; - zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); - zval_ptr_dtor_nogc(free_op2); + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { @@ -26186,13 +25519,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -26204,18 +25533,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval_ptr_dtor_nogc(free_op2); + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -26236,31 +25568,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == 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 = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -26269,11 +25599,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_free_op free_op2; - zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); - zval_ptr_dtor_nogc(free_op2); + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { @@ -26282,13 +25625,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -26300,18 +25639,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval_ptr_dtor_nogc(free_op2); + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -26332,31 +25674,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == 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 = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -26365,11 +25705,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_free_op free_op2; - zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); - zval_ptr_dtor_nogc(free_op2); + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { @@ -26378,13 +25731,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -26396,18 +25745,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval_ptr_dtor_nogc(free_op2); + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -26428,31 +25780,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == 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 = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -26461,11 +25811,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_free_op free_op2; - zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); - zval_ptr_dtor_nogc(free_op2); + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { @@ -26474,13 +25837,9 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -26492,18 +25851,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval_ptr_dtor_nogc(free_op2); + } if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -26867,6 +26229,9 @@ num_index_dim: goto unset_dim_array; } } + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_R); + } if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R); } @@ -26994,7 +26359,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND USE_OPLINE zval *obj; - zend_class_entry *ce; + zend_class_entry *ce, *scope; zend_function *clone; zend_object_clone_obj_t clone_call; @@ -27040,16 +26405,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) { /* Ensure that if we're calling a private function, we're allowed to do so. */ - if (UNEXPECTED(ce != EG(scope))) { - zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = EX(func)->op_array.scope; + if (UNEXPECTED(ce != scope)) { + zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), scope ? ZSTR_VAL(scope->name) : ""); HANDLE_EXCEPTION(); } } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ - if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { - zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = EX(func)->op_array.scope; + if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) { + zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), scope ? ZSTR_VAL(scope->name) : ""); HANDLE_EXCEPTION(); } @@ -27160,7 +26527,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); @@ -27172,40 +26539,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = EX_CONSTANT(opline->op2); + if (IS_UNUSED != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if (IS_CONST == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = EX_CONSTANT(opline->op2); - do { - if (IS_UNUSED == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_UNUSED != IS_UNUSED) { - ZVAL_DEREF(container); + if (IS_CONST == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, IS_CONST); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_UNUSED != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = EX_CONSTANT(opline->op2); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_UNUSED != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if (IS_CONST == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } FREE_OP(free_op_data1); @@ -28904,7 +28318,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CON static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - zend_class_entry *ce; + zend_class_entry *ce, *scope; zend_class_constant *c; zval *value; USE_OPLINE @@ -28947,15 +28361,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS } if (EXPECTED((c = zend_hash_find_ptr(&ce->constants_table, Z_STR_P(EX_CONSTANT(opline->op2)))) != NULL)) { - if (!zend_verify_const_access(c, EG(scope))) { + scope = EX(func)->op_array.scope; + if (!zend_verify_const_access(c, scope)) { zend_throw_error(NULL, "Cannot access %s const %s::%s", zend_visibility_string(Z_ACCESS_FLAGS(c->value)), ZSTR_VAL(ce->name), Z_STRVAL_P(EX_CONSTANT(opline->op2))); HANDLE_EXCEPTION(); } value = &c->value; if (Z_CONSTANT_P(value)) { - EG(scope) = ce; - zval_update_constant_ex(value, 1, NULL); - EG(scope) = EX(func)->op_array.scope; + zval_update_constant_ex(value, ce); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } @@ -29090,6 +28503,9 @@ num_index_dim: goto unset_dim_array; } } + if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_R); + } if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R); } @@ -29379,7 +28795,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLE if (IS_UNUSED == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -29514,7 +28930,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER( if (IS_UNUSED == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -29649,7 +29065,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER( if (IS_UNUSED == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -29741,7 +29157,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); @@ -29753,40 +29169,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = NULL; + if (IS_UNUSED != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if (IS_UNUSED == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = NULL; - do { - if (IS_UNUSED == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_UNUSED != IS_UNUSED) { - ZVAL_DEREF(container); + if (IS_UNUSED == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, IS_UNUSED); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_UNUSED != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = NULL; - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_UNUSED != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if (IS_UNUSED == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } FREE_OP(free_op_data1); @@ -30324,7 +29787,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDL if (IS_UNUSED == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -30479,7 +29942,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); @@ -30491,40 +29954,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_UNUSED != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if (IS_CV == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); - do { - if (IS_UNUSED == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_UNUSED != IS_UNUSED) { - ZVAL_DEREF(container); + if (IS_CV == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_UNUSED != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_UNUSED != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if (IS_CV == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } FREE_OP(free_op_data1); @@ -32283,6 +31793,9 @@ num_index_dim: goto unset_dim_array; } } + if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_R); + } if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R); } @@ -32572,7 +32085,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(Z if (IS_UNUSED == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -32727,7 +32240,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op2, free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); @@ -32739,40 +32252,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + if (IS_UNUSED != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - do { - if (IS_UNUSED == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_UNUSED != IS_UNUSED) { - ZVAL_DEREF(container); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, (IS_TMP_VAR|IS_VAR)); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_UNUSED != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_UNUSED != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } zval_ptr_dtor_nogc(free_op2); FREE_OP(free_op_data1); @@ -34537,6 +34097,9 @@ num_index_dim: goto unset_dim_array; } } + if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_R); + } if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R); } @@ -35338,14 +34901,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER( retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); if (!EX(return_value)) { - if (IS_CV == IS_TMP_VAR) { - } } else { - ZVAL_COPY_VALUE(EX(return_value), retval_ptr); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; - if (IS_CV != IS_TMP_VAR) { - zval_opt_copy_ctor_no_imm(EX(return_value)); + if (IS_CV == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); + break; + } + + ZVAL_NEW_REF(EX(return_value), retval_ptr); + if (IS_CV == IS_CONST) { + if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); } } break; @@ -35355,13 +34920,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER( if (IS_CV == IS_VAR) { if (retval_ptr == &EG(uninitialized_zval) || - (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF))) { + (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr))) { zend_error(E_NOTICE, "Only variable references should be returned by reference"); if (EX(return_value)) { ZVAL_NEW_REF(EX(return_value), retval_ptr); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; - if (Z_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); + } else { + } break; } @@ -35371,8 +34935,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER( ZVAL_MAKE_REF(retval_ptr); Z_ADDREF_P(retval_ptr); ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr)); - Z_VAR_FLAGS_P(EX(return_value)) = IS_VAR_RET_REF; } + } while (0); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); @@ -35639,7 +35203,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) { if (UNEXPECTED(!Z_ISREF_P(arg))) { - 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", @@ -35657,25 +35220,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND ZVAL_UNDEF(param); EX(call)->func = (zend_function*)&zend_pass_function; Z_OBJ(EX(call)->This) = NULL; - ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call))); + ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call)) & ~ZEND_CALL_RELEASE_THIS); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - - ZVAL_NEW_REF(arg, arg); } - Z_ADDREF_P(arg); } else { if (Z_ISREF_P(arg) && !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) { /* don't separate references for __call */ arg = Z_REFVAL_P(arg); } - if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } } - ZVAL_COPY_VALUE(param, arg); + ZVAL_COPY(param, arg); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -35710,7 +35267,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPC USE_OPLINE zval *obj; - zend_class_entry *ce; + zend_class_entry *ce, *scope; zend_function *clone; zend_object_clone_obj_t clone_call; @@ -35756,16 +35313,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPC if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) { /* Ensure that if we're calling a private function, we're allowed to do so. */ - if (UNEXPECTED(ce != EG(scope))) { - zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = EX(func)->op_array.scope; + if (UNEXPECTED(ce != scope)) { + zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), scope ? ZSTR_VAL(scope->name) : ""); HANDLE_EXCEPTION(); } } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ - if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { - zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = EX(func)->op_array.scope; + if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) { + zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), scope ? ZSTR_VAL(scope->name) : ""); HANDLE_EXCEPTION(); } @@ -35883,89 +35442,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCO static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_op_array *new_op_array=NULL; + zend_op_array *new_op_array; zval *inc_filename; - zval tmp_inc_filename; - zend_bool failure_retval=0; SAVE_OPLINE(); - inc_filename = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); - - ZVAL_UNDEF(&tmp_inc_filename); - if (Z_TYPE_P(inc_filename) != IS_STRING) { - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(inc_filename) == IS_UNDEF)) { - inc_filename = GET_OP1_UNDEF_CV(inc_filename, BP_VAR_R); - } - ZVAL_STR(&tmp_inc_filename, zval_get_string(inc_filename)); - inc_filename = &tmp_inc_filename; - } - - if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { - if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { - zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename)); - } else { - zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename)); - } - } else { - switch (opline->extended_value) { - case ZEND_INCLUDE_ONCE: - case ZEND_REQUIRE_ONCE: { - zend_file_handle file_handle; - zend_string *resolved_path; - - resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), (int)Z_STRLEN_P(inc_filename)); - if (resolved_path) { - failure_retval = zend_hash_exists(&EG(included_files), resolved_path); - } else { - resolved_path = zend_string_copy(Z_STR_P(inc_filename)); - } - - if (failure_retval) { - /* do nothing, file already included */ - } else if (SUCCESS == zend_stream_open(ZSTR_VAL(resolved_path), &file_handle)) { - - if (!file_handle.opened_path) { - file_handle.opened_path = zend_string_copy(resolved_path); - } - - if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path)) { - new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE)); - zend_destroy_file_handle(&file_handle); - } else { - zend_file_handle_dtor(&file_handle); - failure_retval=1; - } - } else { - if (opline->extended_value == ZEND_INCLUDE_ONCE) { - zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename)); - } else { - zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename)); - } - } - zend_string_release(resolved_path); - } - break; - case ZEND_INCLUDE: - case ZEND_REQUIRE: - new_op_array = compile_filename(opline->extended_value, inc_filename); - break; - case ZEND_EVAL: { - char *eval_desc = zend_make_compiled_string_description("eval()'d code"); - - new_op_array = zend_compile_string(inc_filename, eval_desc); - efree(eval_desc); - } - break; - EMPTY_SWITCH_DEFAULT_CASE() - } - } - if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) { - zend_string_release(Z_STR(tmp_inc_filename)); - } + inc_filename = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); + new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); + } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + } } else if (EXPECTED(new_op_array != NULL)) { zval *return_value = NULL; zend_execute_data *call; @@ -35974,21 +35464,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE return_value = EX_VAR(opline->result.var); } - new_op_array->scope = EG(scope); + new_op_array->scope = EX(func)->op_array.scope; - call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE, + call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, (zend_function*)new_op_array, 0, Z_TYPE(EX(This)) != IS_OBJECT ? Z_CE(EX(This)) : NULL, Z_TYPE(EX(This)) == IS_OBJECT ? Z_OBJ(EX(This)) : NULL); - if (EX(symbol_table)) { + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { call->symbol_table = EX(symbol_table); } else { call->symbol_table = zend_rebuild_symbol_table(); } call->prev_execute_data = execute_data; - i_init_code_execute_data(call, new_op_array, return_value); + i_init_code_execute_data(call, new_op_array, return_value); if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -36003,12 +35493,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE zend_throw_exception_internal(NULL); HANDLE_EXCEPTION(); } - } else if (RETURN_VALUE_USED(opline)) { - ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval); + ZVAL_FALSE(EX_VAR(opline->result.var)); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -36332,9 +35821,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_O } else if (IS_CV == IS_VAR && ref) { zend_reference *r = Z_REF_P(ref); - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) { efree_size(r, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); } } ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); @@ -36371,9 +35861,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_ } else if (IS_CV == IS_VAR && ref) { zend_reference *r = Z_REF_P(ref); - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) { efree_size(r, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); } } ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); @@ -36387,30 +35878,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND USE_OPLINE zval *value; + zval *result = EX_VAR(opline->result.var); value = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { SAVE_OPLINE(); GET_OP1_UNDEF_CV(value, BP_VAR_R); - ZVAL_NULL(EX_VAR(opline->result.var)); + ZVAL_NULL(result); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(value)) { - ZVAL_COPY(EX_VAR(opline->result.var), Z_REFVAL_P(value)); - if (IS_CV == IS_VAR) { + if (IS_CV == IS_CV) { + ZVAL_DEREF(value); + ZVAL_COPY(result, value); + } else if (IS_CV == IS_VAR) { + if (UNEXPECTED(Z_ISREF_P(value))) { + ZVAL_COPY_VALUE(result, Z_REFVAL_P(value)); if (UNEXPECTED(Z_DELREF_P(value) == 0)) { efree_size(Z_REF_P(value), sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); } + } else { + ZVAL_COPY_VALUE(result, value); } } else { - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); + ZVAL_COPY_VALUE(result, value); if (IS_CV == IS_CONST) { if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) { - zval_copy_ctor_func(EX_VAR(opline->result.var)); + zval_copy_ctor_func(result); } - } else if (IS_CV == IS_CV) { - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); } } ZEND_VM_NEXT_OPCODE(); @@ -37289,11 +36786,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var); if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); @@ -37301,40 +36798,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = EX_CONSTANT(opline->op2); + if (IS_CV != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if (IS_CONST == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = EX_CONSTANT(opline->op2); - do { - if (IS_CV == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_CV != IS_UNUSED) { - ZVAL_DEREF(container); + if (IS_CONST == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, IS_CONST); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_CV != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = EX_CONSTANT(opline->op2); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_CV != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if (IS_CONST == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } FREE_OP(free_op_data1); @@ -37908,7 +37452,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HAND zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST); @@ -37940,7 +37484,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HAN zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var); zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST); @@ -37958,7 +37502,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HAN zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST); @@ -37994,7 +37538,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CON HANDLE_EXCEPTION(); } - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST); @@ -38009,7 +37553,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_ zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var); zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST); @@ -38282,93 +37826,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CV_CONST_HANDL { USE_OPLINE - zval *container; - zval *offset = EX_CONSTANT(opline->op2); SAVE_OPLINE(); container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); - -try_fetch_list: - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value; - zend_string *str; - zend_ulong hval; - -assign_again_list: - if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_list: - value = zend_hash_index_find(Z_ARRVAL_P(container), hval); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined offset: " ZEND_ULONG_FMT, hval); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_list; - } - -str_index_list: - value = zend_hash_find(Z_ARRVAL_P(container), str); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(str)); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (UNEXPECTED(str != Z_STR_P(offset))) { - zend_string_release(str); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto assign_again_list; - } else if (Z_TYPE_P(offset) == IS_NULL) { - str = ZSTR_EMPTY_ALLOC(); - goto str_index_list; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(offset), Z_RES_HANDLE_P(offset)); - hval = Z_RES_HANDLE_P(offset); - } else { - zend_error(E_WARNING, "Illegal offset type"); - } - } else if (IS_CV != IS_CONST && - UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && - EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { - zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, offset, BP_VAR_R, result); - - if (retval) { - if (result != retval) { - ZVAL_COPY(result, retval); - } - } else { - ZVAL_NULL(result); - } - } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) { - container = Z_REFVAL_P(container); - goto try_fetch_list; - } else { - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - GET_OP1_UNDEF_CV(container, BP_VAR_R); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - } + zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -39072,31 +38534,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == 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 = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((opline+1)->op1); - value = zend_assign_to_variable(variable_ptr, value, IS_CONST); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = EX_CONSTANT((opline+1)->op1); + value = zend_assign_to_variable(variable_ptr, value, IS_CONST); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -39105,11 +38565,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = EX_CONSTANT((opline+1)->op1); + + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = EX_CONSTANT(opline->op2); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CONST == IS_UNUSED) { @@ -39118,13 +38591,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -39136,18 +38605,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = EX_CONSTANT(opline->op2); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CONST != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -39168,31 +38640,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == 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 = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -39201,11 +38671,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = EX_CONSTANT(opline->op2); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CONST == IS_UNUSED) { @@ -39214,13 +38697,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -39232,18 +38711,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = EX_CONSTANT(opline->op2); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CONST != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -39264,31 +38746,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == 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 = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -39297,11 +38777,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - zval *property_name = EX_CONSTANT(opline->op2); + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CONST == IS_UNUSED) { @@ -39310,13 +38803,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -39328,18 +38817,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = EX_CONSTANT(opline->op2); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CONST != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -39360,31 +38852,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == 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 = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -39393,11 +38883,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = EX_CONSTANT(opline->op2); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CONST == IS_UNUSED) { @@ -39406,13 +38909,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -39424,18 +38923,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = EX_CONSTANT(opline->op2); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CONST != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -39953,7 +39455,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLE zend_string *key; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var); if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); @@ -40018,6 +39520,9 @@ num_index_dim: goto unset_dim_array; } } + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_R); + } if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R); } @@ -40167,7 +39672,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); @@ -40441,7 +39946,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE if (IS_CV == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -40647,7 +40152,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_CONST_HAND if (opline->extended_value) { if (Z_CONSTANT_P(value)) { - if (UNEXPECTED(zval_update_constant_ex(value, 1, NULL) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(value, EX(func)->op_array.scope) != SUCCESS)) { ZVAL_NULL(variable_ptr); HANDLE_EXCEPTION(); } @@ -40810,7 +40315,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND if (IS_CV == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -41151,8 +40656,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER } else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_FUNCTION && - UNEXPECTED(!(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { - + UNEXPECTED(!Z_ISREF_P(value_ptr))) { zend_error(E_NOTICE, "Only variables should be assigned by reference"); if (UNEXPECTED(EG(exception) != NULL)) { if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);}; @@ -41423,7 +40927,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND if (IS_CV == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -41515,11 +41019,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var); if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); @@ -41527,40 +41031,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = NULL; + if (IS_CV != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if (IS_UNUSED == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = NULL; - do { - if (IS_CV == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_CV != IS_UNUSED) { - ZVAL_DEREF(container); + if (IS_UNUSED == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, IS_UNUSED); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_CV != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = NULL; - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_CV != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if (IS_UNUSED == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } FREE_OP(free_op_data1); @@ -42094,7 +41645,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HA zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var); zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, NULL, IS_UNUSED); @@ -42134,7 +41685,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNU HANDLE_EXCEPTION(); } - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED); @@ -42157,31 +41708,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == 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 = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((opline+1)->op1); - value = zend_assign_to_variable(variable_ptr, value, IS_CONST); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = EX_CONSTANT((opline+1)->op1); + value = zend_assign_to_variable(variable_ptr, value, IS_CONST); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -42190,11 +41739,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = EX_CONSTANT((opline+1)->op1); - zval *property_name = NULL; + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + zend_assign_to_object_dim(object_ptr, dim, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_UNUSED == IS_UNUSED) { @@ -42203,13 +41765,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -42221,18 +41779,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = NULL; +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_UNUSED != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -42253,31 +41814,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == 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 = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -42286,11 +41845,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zval *property_name = NULL; + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_UNUSED == IS_UNUSED) { @@ -42299,13 +41871,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -42317,18 +41885,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = NULL; +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_UNUSED != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -42349,31 +41920,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == 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 = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -42382,11 +41951,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = NULL; + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_UNUSED == IS_UNUSED) { @@ -42395,13 +41977,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -42413,18 +41991,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = NULL; +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_UNUSED != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -42445,31 +42026,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == 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 = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -42478,11 +42057,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - zval *property_name = NULL; + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + zend_assign_to_object_dim(object_ptr, dim, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_UNUSED == IS_UNUSED) { @@ -42491,13 +42083,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -42509,18 +42097,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = NULL; +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_UNUSED != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -43057,7 +42648,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z if (IS_CV == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -43849,11 +43440,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var); if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); @@ -43861,40 +43452,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_CV != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if (IS_CV == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); - do { - if (IS_CV == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_CV != IS_UNUSED) { - ZVAL_DEREF(container); + if (IS_CV == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_CV != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_CV != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if (IS_CV == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } FREE_OP(free_op_data1); @@ -44329,8 +43967,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -44345,7 +43983,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER SAVE_OPLINE(); container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var); - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -44361,9 +43999,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLE zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var); - zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -44379,8 +44017,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLE zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var); - zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -44402,7 +44040,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_ HANDLE_EXCEPTION(); } container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var); - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } @@ -44415,8 +44053,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_ HANDLE_EXCEPTION(); } - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); } @@ -44430,9 +44068,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HAN zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var); - zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -44703,93 +44341,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CV_CV_HANDLER( { USE_OPLINE - zval *container; - zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); SAVE_OPLINE(); container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); - -try_fetch_list: - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value; - zend_string *str; - zend_ulong hval; - -assign_again_list: - if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_list: - value = zend_hash_index_find(Z_ARRVAL_P(container), hval); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined offset: " ZEND_ULONG_FMT, hval); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_list; - } - -str_index_list: - value = zend_hash_find(Z_ARRVAL_P(container), str); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(str)); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (UNEXPECTED(str != Z_STR_P(offset))) { - zend_string_release(str); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto assign_again_list; - } else if (Z_TYPE_P(offset) == IS_NULL) { - str = ZSTR_EMPTY_ALLOC(); - goto str_index_list; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(offset), Z_RES_HANDLE_P(offset)); - hval = Z_RES_HANDLE_P(offset); - } else { - zend_error(E_WARNING, "Illegal offset type"); - } - } else if (IS_CV != IS_CONST && - UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && - EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { - zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, offset, BP_VAR_R, result); - - if (retval) { - if (result != retval) { - ZVAL_COPY(result, retval); - } - } else { - ZVAL_NULL(result); - } - } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) { - container = Z_REFVAL_P(container); - goto try_fetch_list; - } else { - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - GET_OP1_UNDEF_CV(container, BP_VAR_R); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - } + zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -45493,31 +45049,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == 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 = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((opline+1)->op1); - value = zend_assign_to_variable(variable_ptr, value, IS_CONST); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = EX_CONSTANT((opline+1)->op1); + value = zend_assign_to_variable(variable_ptr, value, IS_CONST); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -45526,11 +45080,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = EX_CONSTANT((opline+1)->op1); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + zend_assign_to_object_dim(object_ptr, dim, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CV == IS_UNUSED) { @@ -45539,13 +45106,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -45557,18 +45120,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CV != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -45589,31 +45155,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == 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 = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -45622,11 +45186,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + zend_assign_to_object_dim(object_ptr, dim, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CV == IS_UNUSED) { @@ -45635,13 +45212,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -45653,18 +45226,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CV != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -45685,31 +45261,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == 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 = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -45718,11 +45292,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CV == IS_UNUSED) { @@ -45731,13 +45318,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -45749,18 +45332,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CV != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -45781,31 +45367,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == 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 = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -45814,11 +45398,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if (IS_CV == IS_UNUSED) { @@ -45827,13 +45424,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -45845,18 +45438,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if (IS_CV != IS_UNUSED) { + + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -45940,8 +45536,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER( } else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_FUNCTION && - UNEXPECTED(!(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { - + UNEXPECTED(!Z_ISREF_P(value_ptr))) { zend_error(E_NOTICE, "Only variables should be assigned by reference"); if (UNEXPECTED(EG(exception) != NULL)) { @@ -46370,7 +45965,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(Z zend_string *key; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var); if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); @@ -46435,6 +46030,9 @@ num_index_dim: goto unset_dim_array; } } + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_R); + } if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R); } @@ -46501,7 +46099,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); @@ -46724,7 +46322,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_ if (IS_CV == IS_VAR && (value_ptr == &EG(uninitialized_zval) || (opline->extended_value == ZEND_RETURNS_FUNCTION && - !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + !Z_ISREF_P(value_ptr)))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); } else { ZVAL_MAKE_REF(value_ptr); @@ -47480,11 +47078,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP { USE_OPLINE zend_free_op free_op2, free_op_data1; - zval *var_ptr, rv; + zval *var_ptr; zval *value, *container, *dim; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var); if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); @@ -47492,40 +47090,87 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP HANDLE_EXCEPTION(); } - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + if (IS_CV != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +assign_dim_op_array: + SEPARATE_ARRAY(container); +assign_dim_op_new_array: + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); + if (UNEXPECTED(!var_ptr)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_op_ret_null; + } + } else { + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - do { - if (IS_CV == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - if (IS_CV != IS_UNUSED) { - ZVAL_DEREF(container); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim); + } else { + var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim); } - if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); - break; + if (UNEXPECTED(!var_ptr)) { + goto assign_dim_op_ret_null; } + ZVAL_DEREF(var_ptr); + SEPARATE_ZVAL_NOREF(var_ptr); } - zend_fetch_dimension_address_RW(&rv, container, dim, (IS_TMP_VAR|IS_VAR)); value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); - if (UNEXPECTED(Z_ISERROR(rv))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + binary_op(var_ptr, var_ptr, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + } else { + if (IS_CV != IS_UNUSED) { + if (EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto assign_dim_op_array; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_RW); + goto assign_dim_op_convert_to_array; } - } else { - ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT); - var_ptr = Z_INDIRECT(rv); - ZVAL_DEREF(var_ptr); - SEPARATE_ZVAL_NOREF(var_ptr); + } - binary_op(var_ptr, var_ptr, value); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); + zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op); + } else if (IS_CV != IS_UNUSED) { + if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { + if (UNEXPECTED(Z_STRLEN_P(container) == 0)) { + zval_ptr_dtor_nogc(container); +assign_dim_op_convert_to_array: + ZVAL_NEW_ARR(container); + zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0); + goto assign_dim_op_new_array; + } + + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + zend_throw_error(NULL, "[] operator not supported for strings"); + } else { + zend_check_string_offset(dim, BP_VAR_RW); + zend_wrong_string_offset(); + } + } else { + if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) { + goto assign_dim_op_convert_to_array; + } + if (UNEXPECTED(!Z_ISERROR_P(container))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_op_ret_null: + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } + value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1); } - } while (0); + } zval_ptr_dtor_nogc(free_op2); FREE_OP(free_op_data1); @@ -47964,7 +47609,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HAN zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR)); zval_ptr_dtor_nogc(free_op2); @@ -47996,7 +47641,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HA zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var); zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR)); zval_ptr_dtor_nogc(free_op2); @@ -48014,7 +47659,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HA zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR)); zval_ptr_dtor_nogc(free_op2); @@ -48050,7 +47695,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP HANDLE_EXCEPTION(); } - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR)); zval_ptr_dtor_nogc(free_op2); @@ -48065,7 +47710,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var); zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR)); zval_ptr_dtor_nogc(free_op2); @@ -48339,94 +47984,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op2; zval *container; - zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); SAVE_OPLINE(); container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); - -try_fetch_list: - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value; - zend_string *str; - zend_ulong hval; - -assign_again_list: - if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_list: - value = zend_hash_index_find(Z_ARRVAL_P(container), hval); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined offset: " ZEND_ULONG_FMT, hval); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_list; - } - -str_index_list: - value = zend_hash_find(Z_ARRVAL_P(container), str); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(str)); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (UNEXPECTED(str != Z_STR_P(offset))) { - zend_string_release(str); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto assign_again_list; - } else if (Z_TYPE_P(offset) == IS_NULL) { - str = ZSTR_EMPTY_ALLOC(); - goto str_index_list; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(offset), Z_RES_HANDLE_P(offset)); - hval = Z_RES_HANDLE_P(offset); - } else { - zend_error(E_WARNING, "Illegal offset type"); - } - } else if (IS_CV != IS_CONST && - UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && - EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { - zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, offset, BP_VAR_R, result); - - if (retval) { - if (result != retval) { - ZVAL_COPY(result, retval); - } - } else { - ZVAL_NULL(result); - } - } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) { - container = Z_REFVAL_P(container); - goto try_fetch_list; - } else { - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - GET_OP1_UNDEF_CV(container, BP_VAR_R); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - } + zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)); zval_ptr_dtor_nogc(free_op2); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -49130,31 +48693,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == 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 = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((opline+1)->op1); - value = zend_assign_to_variable(variable_ptr, value, IS_CONST); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = EX_CONSTANT((opline+1)->op1); + value = zend_assign_to_variable(variable_ptr, value, IS_CONST); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -49163,11 +48724,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_free_op free_op2; - zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); - zval_ptr_dtor_nogc(free_op2); + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { @@ -49176,13 +48750,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -49194,18 +48764,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval_ptr_dtor_nogc(free_op2); + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -49226,31 +48799,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == 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 = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -49259,11 +48830,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_free_op free_op2; - zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); - zval_ptr_dtor_nogc(free_op2); + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { @@ -49272,13 +48856,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -49290,18 +48870,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval_ptr_dtor_nogc(free_op2); + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -49322,31 +48905,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == 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 = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -49355,11 +48936,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_free_op free_op2; - zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); - zval_ptr_dtor_nogc(free_op2); + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { @@ -49368,13 +48962,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -49386,18 +48976,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval_ptr_dtor_nogc(free_op2); + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -49418,31 +49011,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == 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 = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { object_ptr = Z_REFVAL_P(object_ptr); @@ -49451,11 +49042,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_free_op free_op2; - zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); - zval_ptr_dtor_nogc(free_op2); + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { @@ -49464,13 +49068,9 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); } } else { @@ -49482,18 +49082,21 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } } + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval_ptr_dtor_nogc(free_op2); + } /* assign_dim has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); @@ -49898,7 +49501,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDL zend_string *key; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var); if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -49963,6 +49566,9 @@ num_index_dim: goto unset_dim_array; } } + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + container = GET_OP1_UNDEF_CV(container, BP_VAR_R); + } if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = GET_OP2_UNDEF_CV(offset, BP_VAR_R); } @@ -50031,7 +49637,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var); + container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { zend_throw_error(NULL, "Using $this when not in object context"); @@ -50517,7 +50123,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND USE_OPLINE zend_free_op free_op1; zval *obj; - zend_class_entry *ce; + zend_class_entry *ce, *scope; zend_function *clone; zend_object_clone_obj_t clone_call; @@ -50563,16 +50169,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) { /* Ensure that if we're calling a private function, we're allowed to do so. */ - if (UNEXPECTED(ce != EG(scope))) { - zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = EX(func)->op_array.scope; + if (UNEXPECTED(ce != scope)) { + zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(ce->name), scope ? ZSTR_VAL(scope->name) : ""); zval_ptr_dtor_nogc(free_op1); HANDLE_EXCEPTION(); } } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ - if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { - zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), EG(scope) ? ZSTR_VAL(EG(scope)->name) : ""); + scope = EX(func)->op_array.scope; + if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) { + zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(ce->name), scope ? ZSTR_VAL(scope->name) : ""); zval_ptr_dtor_nogc(free_op1); HANDLE_EXCEPTION(); } @@ -50591,89 +50199,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_op_array *new_op_array=NULL; + zend_op_array *new_op_array; zend_free_op free_op1; zval *inc_filename; - zval tmp_inc_filename; - zend_bool failure_retval=0; SAVE_OPLINE(); inc_filename = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - - ZVAL_UNDEF(&tmp_inc_filename); - if (Z_TYPE_P(inc_filename) != IS_STRING) { - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(inc_filename) == IS_UNDEF)) { - inc_filename = GET_OP1_UNDEF_CV(inc_filename, BP_VAR_R); - } - ZVAL_STR(&tmp_inc_filename, zval_get_string(inc_filename)); - inc_filename = &tmp_inc_filename; - } - - if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { - if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { - zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename)); - } else { - zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename)); - } - } else { - switch (opline->extended_value) { - case ZEND_INCLUDE_ONCE: - case ZEND_REQUIRE_ONCE: { - zend_file_handle file_handle; - zend_string *resolved_path; - - resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), (int)Z_STRLEN_P(inc_filename)); - if (resolved_path) { - failure_retval = zend_hash_exists(&EG(included_files), resolved_path); - } else { - resolved_path = zend_string_copy(Z_STR_P(inc_filename)); - } - - if (failure_retval) { - /* do nothing, file already included */ - } else if (SUCCESS == zend_stream_open(ZSTR_VAL(resolved_path), &file_handle)) { - - if (!file_handle.opened_path) { - file_handle.opened_path = zend_string_copy(resolved_path); - } - - if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path)) { - new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE)); - zend_destroy_file_handle(&file_handle); - } else { - zend_file_handle_dtor(&file_handle); - failure_retval=1; - } - } else { - if (opline->extended_value == ZEND_INCLUDE_ONCE) { - zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename)); - } else { - zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename)); - } - } - zend_string_release(resolved_path); - } - break; - case ZEND_INCLUDE: - case ZEND_REQUIRE: - new_op_array = compile_filename(opline->extended_value, inc_filename); - break; - case ZEND_EVAL: { - char *eval_desc = zend_make_compiled_string_description("eval()'d code"); - - new_op_array = zend_compile_string(inc_filename, eval_desc); - efree(eval_desc); - } - break; - EMPTY_SWITCH_DEFAULT_CASE() - } - } - if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) { - zend_string_release(Z_STR(tmp_inc_filename)); - } + new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); zval_ptr_dtor_nogc(free_op1); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); + } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + } } else if (EXPECTED(new_op_array != NULL)) { zval *return_value = NULL; zend_execute_data *call; @@ -50682,21 +50221,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA return_value = EX_VAR(opline->result.var); } - new_op_array->scope = EG(scope); + new_op_array->scope = EX(func)->op_array.scope; - call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE, + call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, (zend_function*)new_op_array, 0, Z_TYPE(EX(This)) != IS_OBJECT ? Z_CE(EX(This)) : NULL, Z_TYPE(EX(This)) == IS_OBJECT ? Z_OBJ(EX(This)) : NULL); - if (EX(symbol_table)) { + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { call->symbol_table = EX(symbol_table); } else { call->symbol_table = zend_rebuild_symbol_table(); } call->prev_execute_data = execute_data; - i_init_code_execute_data(call, new_op_array, return_value); + i_init_code_execute_data(call, new_op_array, return_value); if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -50711,12 +50250,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA zend_throw_exception_internal(NULL); HANDLE_EXCEPTION(); } - } else if (RETURN_VALUE_USED(opline)) { - ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval); + ZVAL_FALSE(EX_VAR(opline->result.var)); } - ZEND_VM_INTERRUPT_CHECK(); - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXIT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -51637,93 +51175,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_TMPVAR_CONST_H { USE_OPLINE zend_free_op free_op1; - zval *container; - zval *offset = EX_CONSTANT(opline->op2); SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - -try_fetch_list: - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value; - zend_string *str; - zend_ulong hval; - -assign_again_list: - if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_list: - value = zend_hash_index_find(Z_ARRVAL_P(container), hval); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined offset: " ZEND_ULONG_FMT, hval); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_list; - } - -str_index_list: - value = zend_hash_find(Z_ARRVAL_P(container), str); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(str)); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (UNEXPECTED(str != Z_STR_P(offset))) { - zend_string_release(str); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto assign_again_list; - } else if (Z_TYPE_P(offset) == IS_NULL) { - str = ZSTR_EMPTY_ALLOC(); - goto str_index_list; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(offset), Z_RES_HANDLE_P(offset)); - hval = Z_RES_HANDLE_P(offset); - } else { - zend_error(E_WARNING, "Illegal offset type"); - } - } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && - UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && - EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { - zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, offset, BP_VAR_R, result); - - if (retval) { - if (result != retval) { - ZVAL_COPY(result, retval); - } - } else { - ZVAL_NULL(result); - } - } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) { - container = Z_REFVAL_P(container); - goto try_fetch_list; - } else { - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - GET_OP1_UNDEF_CV(container, BP_VAR_R); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - } + zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -53884,7 +53340,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HAN SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); zval_ptr_dtor_nogc(free_op1); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -53898,7 +53354,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HA SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var), IS_CV); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV); zval_ptr_dtor_nogc(free_op1); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -53980,93 +53436,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_TMPVAR_CV_HAND { USE_OPLINE zend_free_op free_op1; - zval *container; - zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - -try_fetch_list: - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value; - zend_string *str; - zend_ulong hval; - -assign_again_list: - if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_list: - value = zend_hash_index_find(Z_ARRVAL_P(container), hval); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined offset: " ZEND_ULONG_FMT, hval); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_list; - } - -str_index_list: - value = zend_hash_find(Z_ARRVAL_P(container), str); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(str)); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (UNEXPECTED(str != Z_STR_P(offset))) { - zend_string_release(str); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto assign_again_list; - } else if (Z_TYPE_P(offset) == IS_NULL) { - str = ZSTR_EMPTY_ALLOC(); - goto str_index_list; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(offset), Z_RES_HANDLE_P(offset)); - hval = Z_RES_HANDLE_P(offset); - } else { - zend_error(E_WARNING, "Illegal offset type"); - } - } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && - UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && - EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { - zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, offset, BP_VAR_R, result); - - if (retval) { - if (result != retval) { - ZVAL_COPY(result, retval); - } - } else { - ZVAL_NULL(result); - } - } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) { - container = Z_REFVAL_P(container); - goto try_fetch_list; - } else { - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - GET_OP1_UNDEF_CV(container, BP_VAR_R); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - } + zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -55226,94 +54600,12 @@ fetch_obj_is_no_object: static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; - zend_free_op free_op2; + zend_free_op free_op1, free_op2; zval *container; - zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - -try_fetch_list: - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value; - zend_string *str; - zend_ulong hval; - -assign_again_list: - if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_list: - value = zend_hash_index_find(Z_ARRVAL_P(container), hval); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined offset: " ZEND_ULONG_FMT, hval); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_list; - } - -str_index_list: - value = zend_hash_find(Z_ARRVAL_P(container), str); - - if (UNEXPECTED(value == NULL)) { - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(str)); - ZVAL_NULL(EX_VAR(opline->result.var)); - } else { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (UNEXPECTED(str != Z_STR_P(offset))) { - zend_string_release(str); - } - } else if (EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto assign_again_list; - } else if (Z_TYPE_P(offset) == IS_NULL) { - str = ZSTR_EMPTY_ALLOC(); - goto str_index_list; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index_list; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(offset), Z_RES_HANDLE_P(offset)); - hval = Z_RES_HANDLE_P(offset); - } else { - zend_error(E_WARNING, "Illegal offset type"); - } - } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && - UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && - EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { - zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, offset, BP_VAR_R, result); - - if (retval) { - if (result != retval) { - ZVAL_COPY(result, retval); - } - } else { - ZVAL_NULL(result); - } - } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(container) == IS_REFERENCE) { - container = Z_REFVAL_P(container); - goto try_fetch_list; - } else { - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - GET_OP1_UNDEF_CV(container, BP_VAR_R); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - } + zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)); zval_ptr_dtor_nogc(free_op2); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } diff --git a/Zend/zend_vm_execute.skl b/Zend/zend_vm_execute.skl index ff877df76e..ebc6474ae5 100644 --- a/Zend/zend_vm_execute.skl +++ b/Zend/zend_vm_execute.skl @@ -9,6 +9,7 @@ ZEND_API void {%EXECUTOR_NAME%}_ex(zend_execute_data *ex) {%INTERNAL_LABELS%} LOAD_OPLINE(); + ZEND_VM_INTERRUPT_CHECK(); while (1) { {%ZEND_VM_CONTINUE_LABEL%} @@ -28,7 +29,7 @@ ZEND_API void zend_{%EXECUTOR_NAME%}(zend_op_array *op_array, zval *return_value return; } - execute_data = zend_vm_stack_push_call_frame(ZEND_CALL_TOP_CODE, + execute_data = zend_vm_stack_push_call_frame(ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, (zend_function*)op_array, 0, zend_get_called_scope(EG(current_execute_data)), zend_get_this_object(EG(current_execute_data))); if (EG(current_execute_data)) { execute_data->symbol_table = zend_rebuild_symbol_table(); diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 4407d7dfe3..1f4bb884d2 100644 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -1575,7 +1575,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) out($f,"#define HANDLE_EXCEPTION() LOAD_OPLINE(); ZEND_VM_CONTINUE()\n"); out($f,"#define HANDLE_EXCEPTION_LEAVE() LOAD_OPLINE(); ZEND_VM_LEAVE()\n"); out($f,"#if defined(ZEND_VM_FP_GLOBAL_REG)\n"); - out($f,"# define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_CONTINUE()\n"); + out($f,"# define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_INTERRUPT_CHECK(); ZEND_VM_CONTINUE()\n"); out($f,"# define ZEND_VM_LEAVE() ZEND_VM_CONTINUE()\n"); out($f,"#elif defined(ZEND_VM_IP_GLOBAL_REG)\n"); out($f,"# define ZEND_VM_ENTER() opline = EG(current_execute_data)->opline; return 1\n"); @@ -1611,7 +1611,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) out($f,"#define HANDLE_EXCEPTION_LEAVE() LOAD_OPLINE(); ZEND_VM_LEAVE()\n"); out($f,"#define ZEND_VM_CONTINUE() goto zend_vm_continue\n"); out($f,"#define ZEND_VM_RETURN() return\n"); - out($f,"#define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_CONTINUE()\n"); + out($f,"#define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_INTERRUPT_CHECK(); ZEND_VM_CONTINUE()\n"); out($f,"#define ZEND_VM_LEAVE() ZEND_VM_CONTINUE()\n"); out($f,"#define ZEND_VM_DISPATCH(opcode, opline) dispatch_handler = zend_vm_get_opcode_handler(opcode, opline); goto zend_vm_dispatch;\n"); out($f,"\n"); @@ -1645,7 +1645,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) } out($f,"#define ZEND_VM_CONTINUE() goto *(void**)(OPLINE->handler)\n"); out($f,"#define ZEND_VM_RETURN() return\n"); - out($f,"#define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_CONTINUE()\n"); + out($f,"#define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_INTERRUPT_CHECK(); ZEND_VM_CONTINUE()\n"); out($f,"#define ZEND_VM_LEAVE() ZEND_VM_CONTINUE()\n"); out($f,"#define ZEND_VM_DISPATCH(opcode, opline) goto *(void**)(zend_vm_get_opcode_handler(opcode, opline));\n"); out($f,"\n"); @@ -1747,6 +1747,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) "#else\n" . $m[1]."if (EXPECTED(ret > 0)) {\n" . $m[1]."\texecute_data = EG(current_execute_data);\n". + $m[1]."\tZEND_VM_INTERRUPT_CHECK();\n". $m[1]."} else {\n" . "# ifdef ZEND_VM_IP_GLOBAL_REG\n" . $m[1]."\topline = orig_opline;\n" . diff --git a/ext/bcmath/bcmath.c b/ext/bcmath/bcmath.c index fd14050f05..10450f1968 100644 --- a/ext/bcmath/bcmath.c +++ b/ext/bcmath/bcmath.c @@ -207,6 +207,21 @@ static void php_str2num(bc_num *num, char *str) } /* }}} */ +/* {{{ split_bc_num + Convert to bc_num detecting scale */ +static bc_num split_bc_num(bc_num num) { + bc_num newnum; + if (num->n_refs >= 1) { + return num; + } + newnum = _bc_new_num_ex(0, 0, 0); + *newnum = *num; + newnum->n_refs = 1; + num->n_refs--; + return newnum; +} +/* }}} */ + /* {{{ proto string bcadd(string left_operand, string right_operand [, int scale]) Returns the sum of two arbitrary precision numbers */ PHP_FUNCTION(bcadd) @@ -233,6 +248,7 @@ PHP_FUNCTION(bcadd) bc_add (first, second, &result, scale); if (result->n_scale > scale) { + result = split_bc_num(result); result->n_scale = scale; } @@ -270,6 +286,7 @@ PHP_FUNCTION(bcsub) bc_sub (first, second, &result, scale); if (result->n_scale > scale) { + result = split_bc_num(result); result->n_scale = scale; } @@ -307,6 +324,7 @@ PHP_FUNCTION(bcmul) bc_multiply (first, second, &result, scale); if (result->n_scale > scale) { + result = split_bc_num(result); result->n_scale = scale; } @@ -345,6 +363,7 @@ PHP_FUNCTION(bcdiv) switch (bc_divide(first, second, &result, scale)) { case 0: /* OK */ if (result->n_scale > scale) { + result = split_bc_num(result); result->n_scale = scale; } RETVAL_STR(bc_num2str(result)); @@ -420,8 +439,9 @@ PHP_FUNCTION(bcpowmod) scale_int = (int) ((int)scale < 0 ? 0 : scale); if (bc_raisemod(first, second, mod, &result, scale_int) != -1) { - if (result->n_scale > scale) { - result->n_scale = (int)scale; + if (result->n_scale > scale_int) { + result = split_bc_num(result); + result->n_scale = scale_int; } RETVAL_STR(bc_num2str(result)); } else { @@ -462,6 +482,7 @@ PHP_FUNCTION(bcpow) bc_raise (first, second, &result, scale); if (result->n_scale > scale) { + result = split_bc_num(result); result->n_scale = scale; } @@ -496,6 +517,7 @@ PHP_FUNCTION(bcsqrt) if (bc_sqrt (&result, scale) != 0) { if (result->n_scale > scale) { + result = split_bc_num(result); result->n_scale = scale; } RETVAL_STR(bc_num2str(result)); diff --git a/ext/bcmath/tests/bug72093-win32.phpt b/ext/bcmath/tests/bug72093-win32.phpt new file mode 100644 index 0000000000..a9b2077823 --- /dev/null +++ b/ext/bcmath/tests/bug72093-win32.phpt @@ -0,0 +1,18 @@ +--TEST-- +Bug 72093: bcpowmod accepts negative scale and corrupts _one_ definition +--SKIPIF-- +<?php +if(!extension_loaded("bcmath")) print "skip"; +if (substr(PHP_OS, 0, 3) != 'WIN') { + die('skip valid only for windows'); +} +?> +--FILE-- +<?php +var_dump(bcpowmod(1, "A", 128, -200)); +var_dump(bcpowmod(1, 1.2, 1, 1)); +?> +--EXPECTF-- +string(1) "1" +string(3) "0.0" +bc math warning: non-zero scale in exponent diff --git a/ext/bcmath/tests/bug72093.phpt b/ext/bcmath/tests/bug72093.phpt new file mode 100644 index 0000000000..911af5698f --- /dev/null +++ b/ext/bcmath/tests/bug72093.phpt @@ -0,0 +1,18 @@ +--TEST-- +Bug 72093: bcpowmod accepts negative scale and corrupts _one_ definition +--SKIPIF-- +<?php +if(!extension_loaded("bcmath")) print "skip"; +if (substr(PHP_OS, 0, 3) == 'WIN') { + die('skip Not valid for windows'); +} +?> +--FILE-- +<?php +var_dump(bcpowmod(1, "A", 128, -200)); +var_dump(bcpowmod(1, 1.2, 1, 1)); +?> +--EXPECTF-- +string(1) "1" +bc math warning: non-zero scale in exponent +string(3) "0.0" diff --git a/ext/curl/interface.c b/ext/curl/interface.c index ca899af843..90e2e30987 100644 --- a/ext/curl/interface.c +++ b/ext/curl/interface.c @@ -568,6 +568,13 @@ PHP_MINFO_FUNCTION(curl) #if LIBCURL_VERSION_NUM >= 0x072600 /* 7.38.0 */ {"GSSAPI", CURL_VERSION_GSSAPI}, #endif +#if LIBCURL_VERSION_NUM >= 0x072800 /* 7.40.0 */ + {"KERBEROS5", CURL_VERSION_KERBEROS5}, + {"UNIX_SOCKETS", CURL_VERSION_UNIX_SOCKETS}, +#endif +#if LIBCURL_VERSION_NUM >= 0x072f00 /* 7.47.0 */ + {"PSL", CURL_VERSION_PSL}, +#endif {NULL, 0} }; @@ -847,11 +854,6 @@ PHP_MINIT_FUNCTION(curl) REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS4); REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS5); -#if LIBCURL_VERSION_NUM >= 0x071200 /* Available since 7.18.0 */ - REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS4A); - REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS5_HOSTNAME); -#endif - /* Curl Share constants */ REGISTER_CURL_CONSTANT(CURLSHOPT_NONE); REGISTER_CURL_CONSTANT(CURLSHOPT_SHARE); @@ -860,9 +862,6 @@ PHP_MINIT_FUNCTION(curl) /* Curl Http Version constants (CURLOPT_HTTP_VERSION) */ REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_1_0); REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_1_1); -#if LIBCURL_VERSION_NUM >= 0x072100 /* 7.33.0 */ - REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_2_0); -#endif REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_NONE); /* Curl Lock constants */ @@ -892,9 +891,6 @@ PHP_MINIT_FUNCTION(curl) REGISTER_CURL_CONSTANT(CURL_VERSION_KERBEROS4); REGISTER_CURL_CONSTANT(CURL_VERSION_LIBZ); REGISTER_CURL_CONSTANT(CURL_VERSION_SSL); -#if LIBCURL_VERSION_NUM >= 0x072100 /* 7.33.0 */ - REGISTER_CURL_CONSTANT(CURL_VERSION_HTTP2); -#endif #if LIBCURL_VERSION_NUM >= 0x070a06 /* Available since 7.10.6 */ REGISTER_CURL_CONSTANT(CURLOPT_HTTPAUTH); @@ -999,6 +995,7 @@ PHP_MINIT_FUNCTION(curl) #endif #if LIBCURL_VERSION_NUM >= 0x071000 /* Available since 7.16.0 */ + REGISTER_CURL_CONSTANT(CURLE_SSL_CACERT_BADFILE); REGISTER_CURL_CONSTANT(CURLOPT_SSL_SESSIONID_CACHE); REGISTER_CURL_CONSTANT(CURLMOPT_PIPELINING); #endif @@ -1056,6 +1053,9 @@ PHP_MINIT_FUNCTION(curl) REGISTER_CURL_CONSTANT(CURLPAUSE_SEND_CONT); REGISTER_CURL_CONSTANT(CURL_READFUNC_PAUSE); REGISTER_CURL_CONSTANT(CURL_WRITEFUNC_PAUSE); + + REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS4A); + REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS5_HOSTNAME); #endif #if LIBCURL_VERSION_NUM >= 0x071202 /* Available since 7.18.2 */ @@ -1088,6 +1088,9 @@ PHP_MINIT_FUNCTION(curl) REGISTER_CURL_CONSTANT(CURLOPT_PROXYPASSWORD); REGISTER_CURL_CONSTANT(CURLOPT_PROXYUSERNAME); REGISTER_CURL_CONSTANT(CURLOPT_USERNAME); + REGISTER_CURL_CONSTANT(CURL_REDIR_POST_301); + REGISTER_CURL_CONSTANT(CURL_REDIR_POST_302); + REGISTER_CURL_CONSTANT(CURL_REDIR_POST_ALL); #endif #if LIBCURL_VERSION_NUM >= 0x071303 /* Available since 7.19.3 */ @@ -1117,6 +1120,12 @@ PHP_MINIT_FUNCTION(curl) REGISTER_CURL_CONSTANT(CURLPROTO_SFTP); REGISTER_CURL_CONSTANT(CURLPROTO_TELNET); REGISTER_CURL_CONSTANT(CURLPROTO_TFTP); + + REGISTER_CURL_CONSTANT(CURLPROXY_HTTP_1_0); + + REGISTER_CURL_CONSTANT(CURLFTP_CREATE_DIR); + REGISTER_CURL_CONSTANT(CURLFTP_CREATE_DIR_NONE); + REGISTER_CURL_CONSTANT(CURLFTP_CREATE_DIR_RETRY); #endif #if LIBCURL_VERSION_NUM >= 0x071306 /* Available since 7.19.6 */ @@ -1152,8 +1161,8 @@ PHP_MINIT_FUNCTION(curl) REGISTER_CURL_CONSTANT(CURL_RTSPREQ_PLAY); REGISTER_CURL_CONSTANT(CURL_RTSPREQ_RECEIVE); REGISTER_CURL_CONSTANT(CURL_RTSPREQ_RECORD); - REGISTER_CURL_CONSTANT(CURL_RTSPREQ_SETUP); REGISTER_CURL_CONSTANT(CURL_RTSPREQ_SET_PARAMETER); + REGISTER_CURL_CONSTANT(CURL_RTSPREQ_SETUP); REGISTER_CURL_CONSTANT(CURL_RTSPREQ_TEARDOWN); #endif @@ -1196,6 +1205,7 @@ PHP_MINIT_FUNCTION(curl) #endif #if LIBCURL_VERSION_NUM >= 0x071600 /* Available since 7.22.0 */ + REGISTER_CURL_CONSTANT(CURLAUTH_NTLM_WB); REGISTER_CURL_CONSTANT(CURLGSSAPI_DELEGATION_FLAG); REGISTER_CURL_CONSTANT(CURLGSSAPI_DELEGATION_POLICY_FLAG); REGISTER_CURL_CONSTANT(CURLOPT_GSSAPI_DELEGATION); @@ -1215,18 +1225,119 @@ PHP_MINIT_FUNCTION(curl) REGISTER_CURL_CONSTANT(CURLSSLOPT_ALLOW_BEAST); #endif +#if LIBCURL_VERSION_NUM >= 0x071901 /* Available since 7.25.1 */ + REGISTER_CURL_CONSTANT(CURL_REDIR_POST_303); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071c00 /* Available since 7.28.0 */ + REGISTER_CURL_CONSTANT(CURLSSH_AUTH_AGENT); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071e00 /* Available since 7.30.0 */ + REGISTER_CURL_CONSTANT(CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE); + REGISTER_CURL_CONSTANT(CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE); + REGISTER_CURL_CONSTANT(CURLMOPT_MAX_HOST_CONNECTIONS); + REGISTER_CURL_CONSTANT(CURLMOPT_MAX_PIPELINE_LENGTH); + REGISTER_CURL_CONSTANT(CURLMOPT_MAX_TOTAL_CONNECTIONS); +#endif + +#if LIBCURL_VERSION_NUM >= 0x071f00 /* Available since 7.31.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_SASL_IR); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_DNS_INTERFACE); + REGISTER_CURL_CONSTANT(CURLOPT_DNS_LOCAL_IP4); + REGISTER_CURL_CONSTANT(CURLOPT_DNS_LOCAL_IP6); + REGISTER_CURL_CONSTANT(CURLOPT_XOAUTH2_BEARER); + + REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_2_0); + REGISTER_CURL_CONSTANT(CURL_VERSION_HTTP2); +#endif + #if LIBCURL_VERSION_NUM >= 0x072200 /* Available since 7.34.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_LOGIN_OPTIONS); + REGISTER_CURL_CONSTANT(CURL_SSLVERSION_TLSv1_0); REGISTER_CURL_CONSTANT(CURL_SSLVERSION_TLSv1_1); REGISTER_CURL_CONSTANT(CURL_SSLVERSION_TLSv1_2); #endif -#if LIBCURL_VERSION_NUM >= 0x072B00 /* Available since 7.43.0 */ +#if LIBCURL_VERSION_NUM >= 0x072400 /* Available since 7.36.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_EXPECT_100_TIMEOUT_MS); + REGISTER_CURL_CONSTANT(CURLOPT_SSL_ENABLE_ALPN); + REGISTER_CURL_CONSTANT(CURLOPT_SSL_ENABLE_NPN); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */ + REGISTER_CURL_CONSTANT(CURLHEADER_SEPARATE); + REGISTER_CURL_CONSTANT(CURLHEADER_UNIFIED); + REGISTER_CURL_CONSTANT(CURLOPT_HEADEROPT); + REGISTER_CURL_CONSTANT(CURLOPT_PROXYHEADER); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072600 /* Available since 7.38.0 */ + REGISTER_CURL_CONSTANT(CURLAUTH_NEGOTIATE); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072700 /* Available since 7.39.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_PINNEDPUBLICKEY); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_UNIX_SOCKET_PATH); + + REGISTER_CURL_CONSTANT(CURLPROTO_SMB); + REGISTER_CURL_CONSTANT(CURLPROTO_SMBS); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072900 /* Available since 7.41.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_SSL_VERIFYSTATUS); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072a00 /* Available since 7.42.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_PATH_AS_IS); + REGISTER_CURL_CONSTANT(CURLOPT_SSL_FALSESTART); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ + REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_2); + + REGISTER_CURL_CONSTANT(CURLOPT_PIPEWAIT); + REGISTER_CURL_CONSTANT(CURLOPT_PROXY_SERVICE_NAME); + REGISTER_CURL_CONSTANT(CURLOPT_SERVICE_NAME); + REGISTER_CURL_CONSTANT(CURLPIPE_NOTHING); REGISTER_CURL_CONSTANT(CURLPIPE_HTTP1); REGISTER_CURL_CONSTANT(CURLPIPE_MULTIPLEX); #endif +#if LIBCURL_VERSION_NUM >= 0x072c00 /* Available since 7.44.0 */ + REGISTER_CURL_CONSTANT(CURLSSLOPT_NO_REVOKE); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072d00 /* Available since 7.45.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_DEFAULT_PROTOCOL); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072e00 /* Available since 7.46.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_STREAM_WEIGHT); +#endif + +#if LIBCURL_VERSION_NUM >= 0x072f00 /* Available since 7.47.0 */ + REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_2TLS); +#endif + +#if LIBCURL_VERSION_NUM >= 0x073000 /* Available since 7.48.0 */ + REGISTER_CURL_CONSTANT(CURLOPT_TFTP_NO_OPTIONS); +#endif + +#if LIBCURL_VERSION_NUM >= 0x073100 /* Available since 7.49.0 */ + REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE); + REGISTER_CURL_CONSTANT(CURLOPT_CONNECT_TO); + REGISTER_CURL_CONSTANT(CURLOPT_TCP_FASTOPEN); +#endif + #if CURLOPT_FTPASCII != 0 REGISTER_CURL_CONSTANT(CURLOPT_FTPASCII); #endif @@ -1338,7 +1449,6 @@ static size_t curl_write(char *data, size_t size, size_t nmemb, void *ctx) ZVAL_STRINGL(&argv[1], data, length); fci.size = sizeof(fci); - fci.function_table = EG(function_table); fci.object = NULL; ZVAL_COPY_VALUE(&fci.function_name, &t->func_name); fci.retval = &retval; @@ -1388,7 +1498,6 @@ static int curl_fnmatch(void *ctx, const char *pattern, const char *string) ZVAL_STRING(&argv[2], string); fci.size = sizeof(fci); - fci.function_table = EG(function_table); ZVAL_COPY_VALUE(&fci.function_name, &t->func_name); fci.object = NULL; fci.retval = &retval; @@ -1444,7 +1553,6 @@ static size_t curl_progress(void *clientp, double dltotal, double dlnow, double ZVAL_LONG(&argv[4], (zend_long)ulnow); fci.size = sizeof(fci); - fci.function_table = EG(function_table); ZVAL_COPY_VALUE(&fci.function_name, &t->func_name); fci.object = NULL; fci.retval = &retval; @@ -1506,7 +1614,6 @@ static size_t curl_read(char *data, size_t size, size_t nmemb, void *ctx) ZVAL_LONG(&argv[2], (int)size * nmemb); fci.size = sizeof(fci); - fci.function_table = EG(function_table); ZVAL_COPY_VALUE(&fci.function_name, &t->func_name); fci.object = NULL; fci.retval = &retval; @@ -1573,7 +1680,6 @@ static size_t curl_write_header(char *data, size_t size, size_t nmemb, void *ctx ZVAL_STRINGL(&argv[1], data, length); fci.size = sizeof(fci); - fci.function_table = EG(function_table); ZVAL_COPY_VALUE(&fci.function_name, &t->func_name); fci.object = NULL; fci.retval = &retval; @@ -2173,6 +2279,36 @@ static int _php_curl_setopt(php_curl *ch, zend_long option, zval *zvalue) /* {{{ case CURLOPT_TCP_KEEPIDLE: case CURLOPT_TCP_KEEPINTVL: #endif +#if LIBCURL_VERSION_NUM >= 0x071f00 /* Available since 7.31.0 */ + case CURLOPT_SASL_IR: +#endif +#if LIBCURL_VERSION_NUM >= 0x072400 /* Available since 7.36.0 */ + case CURLOPT_EXPECT_100_TIMEOUT_MS: + case CURLOPT_SSL_ENABLE_ALPN: + case CURLOPT_SSL_ENABLE_NPN: +#endif +#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */ + case CURLOPT_HEADEROPT: +#endif +#if LIBCURL_VERSION_NUM >= 0x072900 /* Available since 7.41.0 */ + case CURLOPT_SSL_VERIFYSTATUS: +#endif +#if LIBCURL_VERSION_NUM >= 0x072a00 /* Available since 7.42.0 */ + case CURLOPT_PATH_AS_IS: + case CURLOPT_SSL_FALSESTART: +#endif +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ + case CURLOPT_PIPEWAIT: +#endif +#if LIBCURL_VERSION_NUM >= 0x072e00 /* Available since 7.46.0 */ + case CURLOPT_STREAM_WEIGHT: +#endif +#if LIBCURL_VERSION_NUM >= 0x073000 /* Available since 7.48.0 */ + case CURLOPT_TFTP_NO_OPTIONS: +#endif +#if LIBCURL_VERSION_NUM >= 0x073100 /* Available since 7.49.0 */ + case CURLOPT_TCP_FASTOPEN: +#endif #if CURLOPT_MUTE != 0 case CURLOPT_MUTE: #endif @@ -2258,6 +2394,19 @@ static int _php_curl_setopt(php_curl *ch, zend_long option, zval *zvalue) /* {{{ #if LIBCURL_VERSION_NUM >= 0x071900 /* Available since 7.25.0 */ case CURLOPT_MAIL_AUTH: #endif +#if LIBCURL_VERSION_NUM >= 0x072200 /* Available since 7.34.0 */ + case CURLOPT_LOGIN_OPTIONS: +#endif +#if LIBCURL_VERSION_NUM >= 0x072700 /* Available since 7.39.0 */ + case CURLOPT_PINNEDPUBLICKEY: +#endif +#if LIBCURL_VERSION_NUM >= 0x072b00 /* Available since 7.43.0 */ + case CURLOPT_PROXY_SERVICE_NAME: + case CURLOPT_SERVICE_NAME: +#endif +#if LIBCURL_VERSION_NUM >= 0x072d00 /* Available since 7.45.0 */ + case CURLOPT_DEFAULT_PROTOCOL: +#endif { zend_string *str = zval_get_string(zvalue); int ret = php_curl_option_str(ch, option, ZSTR_VAL(str), ZSTR_LEN(str), 0); @@ -2275,6 +2424,15 @@ static int _php_curl_setopt(php_curl *ch, zend_long option, zval *zvalue) /* {{{ #if LIBCURL_VERSION_NUM >= 0x071400 /* Available since 7.20.0 */ case CURLOPT_RTSP_SESSION_ID: #endif +#if LIBCURL_VERSION_NUM >= 0x072100 /* Available since 7.33.0 */ + case CURLOPT_DNS_INTERFACE: + case CURLOPT_DNS_LOCAL_IP4: + case CURLOPT_DNS_LOCAL_IP6: + case CURLOPT_XOAUTH2_BEARER: +#endif +#if LIBCURL_VERSION_NUM >= 0x072800 /* Available since 7.40.0 */ + case CURLOPT_UNIX_SOCKET_PATH: +#endif #if LIBCURL_VERSION_NUM >= 0x071004 /* Available since 7.16.4 */ case CURLOPT_KRBLEVEL: #else @@ -2420,6 +2578,12 @@ static int _php_curl_setopt(php_curl *ch, zend_long option, zval *zvalue) /* {{{ #if LIBCURL_VERSION_NUM >= 0x071503 /* Available since 7.21.3 */ case CURLOPT_RESOLVE: #endif +#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */ + case CURLOPT_PROXYHEADER: +#endif +#if LIBCURL_VERSION_NUM >= 0x073100 /* Available since 7.49.0 */ + case CURLOPT_CONNECT_TO: +#endif { zval *current; HashTable *ph; @@ -2458,6 +2622,16 @@ static int _php_curl_setopt(php_curl *ch, zend_long option, zval *zvalue) /* {{{ name = "CURLOPT_RESOLVE"; break; #endif +#if LIBCURL_VERSION_NUM >= 0x072500 /* Available since 7.37.0 */ + case CURLOPT_PROXYHEADER: + name = "CURLOPT_PROXYHEADER"; + break; +#endif +#if LIBCURL_VERSION_NUM >= 0x073100 /* Available since 7.49.0 */ + case CURLOPT_CONNECT_TO: + name = "CURLOPT_CONNECT_TO"; + break; +#endif } php_error_docref(NULL, E_WARNING, "You must pass either an object or an array with the %s argument", name); return FAILURE; diff --git a/ext/curl/multi.c b/ext/curl/multi.c index 641d20f903..ab6d56c438 100644 --- a/ext/curl/multi.c +++ b/ext/curl/multi.c @@ -417,6 +417,13 @@ static int _php_curl_multi_setopt(php_curlm *mh, zend_long option, zval *zvalue, #if LIBCURL_VERSION_NUM >= 0x071003 /* 7.16.3 */ case CURLMOPT_MAXCONNECTS: #endif +#if LIBCURL_VERSION_NUM >= 0x071e00 /* 7.30.0 */ + case CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE: + case CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE: + case CURLMOPT_MAX_HOST_CONNECTIONS: + case CURLMOPT_MAX_PIPELINE_LENGTH: + case CURLMOPT_MAX_TOTAL_CONNECTIONS: +#endif error = curl_multi_setopt(mh->multi, option, zval_get_long(zvalue)); break; diff --git a/ext/curl/tests/bug68937.phpt b/ext/curl/tests/bug68937.phpt index 139cc17abd..0f346cf3fa 100644 --- a/ext/curl/tests/bug68937.phpt +++ b/ext/curl/tests/bug68937.phpt @@ -8,13 +8,19 @@ include 'skipif.inc'; --FILE-- <?php -$ch = curl_init('http://www.google.com/'); +include 'server.inc'; +$host = curl_cli_server_start(); + +$url = "{$host}/get.php"; + +$ch = curl_init($url); curl_setopt_array($ch, array( CURLOPT_HEADER => false, CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_INFILESIZE => 1, CURLOPT_HTTPHEADER => array( + 'Expect:', 'Content-Length: 1', ), CURLOPT_READFUNCTION => 'curl_read', diff --git a/ext/curl/tests/bug68937_2.phpt b/ext/curl/tests/bug68937_2.phpt index 29851ec6e1..c25da3fd71 100644 --- a/ext/curl/tests/bug68937_2.phpt +++ b/ext/curl/tests/bug68937_2.phpt @@ -7,8 +7,12 @@ include 'skipif.inc'; ?> --FILE-- <?php +include 'server.inc'; +$host = curl_cli_server_start(); -$ch = curl_init('http://www.google.com/'); +$url = "{$host}/get.php"; + +$ch = curl_init($url); curl_setopt_array($ch, array( CURLOPT_HEADER => false, CURLOPT_RETURNTRANSFER => true, @@ -16,6 +20,7 @@ curl_setopt_array($ch, array( CURLOPT_INFILESIZE => filesize(__FILE__), CURLOPT_INFILE => fopen(__FILE__, 'r'), CURLOPT_HTTPHEADER => array( + 'Expect:', 'Content-Length: 1', ), CURLOPT_READFUNCTION => 'curl_read', diff --git a/ext/curl/tests/check_win_config.phpt b/ext/curl/tests/check_win_config.phpt index 3d13638f90..fc1c66609a 100644 --- a/ext/curl/tests/check_win_config.phpt +++ b/ext/curl/tests/check_win_config.phpt @@ -42,6 +42,9 @@ SSPI => Yes TLS-SRP => No
HTTP2 => No
GSSAPI => No
+KERBEROS5 => Yes
+UNIX_SOCKETS => No
+PSL => No
Protocols => dict, file, ftp, ftps, gopher, http, https, imap, imaps, ldap, pop3, pop3s, rtsp, scp, sftp, smtp, smtps, telnet, tftp
Host => %s-pc-win32
SSL Version => OpenSSL/%s
diff --git a/ext/dom/xpath.c b/ext/dom/xpath.c index 3cc9abaa3c..e31dcefb78 100644 --- a/ext/dom/xpath.c +++ b/ext/dom/xpath.c @@ -171,7 +171,6 @@ static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, } fci.size = sizeof(fci); - fci.function_table = EG(function_table); obj = valuePop(ctxt); if (obj->stringval == NULL) { diff --git a/ext/exif/exif.c b/ext/exif/exif.c index 0f3c889b21..44b9fee0b1 100644 --- a/ext/exif/exif.c +++ b/ext/exif/exif.c @@ -2946,7 +2946,7 @@ static int exif_process_IFD_TAG(image_info_type *ImageInfo, char *dir_entry, cha /* When there are any characters after the first NUL */ ImageInfo->CopyrightPhotographer = estrdup(value_ptr); ImageInfo->CopyrightEditor = estrndup(value_ptr+length+1, byte_count-length-1); - spprintf(&ImageInfo->Copyright, 0, "%s, %s", value_ptr, value_ptr+length+1); + spprintf(&ImageInfo->Copyright, 0, "%s, %s", ImageInfo->CopyrightPhotographer, ImageInfo->CopyrightEditor); /* format = TAG_FMT_UNDEFINED; this musn't be ASCII */ /* but we are not supposed to change this */ /* keep in mind that image_info does not store editor value */ @@ -3115,6 +3115,11 @@ static int exif_process_IFD_in_JPEG(image_info_type *ImageInfo, char *dir_start, ImageInfo->sections_found |= FOUND_IFD0; + if ((dir_start + 2) >= (offset_base+IFDlength)) { + exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Illegal IFD size"); + return FALSE; + } + NumDirEntries = php_ifd_get16u(dir_start, ImageInfo->motorola_intel); if ((dir_start+2+NumDirEntries*12) > (offset_base+IFDlength)) { @@ -3138,6 +3143,10 @@ static int exif_process_IFD_in_JPEG(image_info_type *ImageInfo, char *dir_start, * Hack to make it process IDF1 I hope * There are 2 IDFs, the second one holds the keys (0x0201 and 0x0202) to the thumbnail */ + if ((dir_start+2+12*de + 4) >= (offset_base+IFDlength)) { + exif_error_docref("exif_read_data#error_ifd" EXIFERR_CC, ImageInfo, E_WARNING, "Illegal IFD size"); + return FALSE; + } NextDirOffset = php_ifd_get32u(dir_start+2+12*de, ImageInfo->motorola_intel); if (NextDirOffset) { /* the next line seems false but here IFDlength means length of all IFDs */ @@ -3187,9 +3196,13 @@ static void exif_process_TIFF_in_JPEG(image_info_type *ImageInfo, char *CharBuf, } /* Check the next two values for correctness. */ + if (length < 8) { + exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Invalid TIFF start (1)"); + return; + } exif_value_2a = php_ifd_get16u(CharBuf+2, ImageInfo->motorola_intel); offset_of_ifd = php_ifd_get32u(CharBuf+4, ImageInfo->motorola_intel); - if ( exif_value_2a != 0x2a || offset_of_ifd < 0x08) { + if (exif_value_2a != 0x2a || offset_of_ifd < 0x08) { exif_error_docref(NULL EXIFERR_CC, ImageInfo, E_WARNING, "Invalid TIFF start (1)"); return; } diff --git a/ext/exif/tests/bug72094.phpt b/ext/exif/tests/bug72094.phpt new file mode 100644 index 0000000000..611faf9152 --- /dev/null +++ b/ext/exif/tests/bug72094.phpt @@ -0,0 +1,61 @@ +--TEST-- +Bug #72094: Out of bounds heap read access in exif header processing +--SKIPIF-- +<?php if (!extension_loaded('exif')) print 'skip exif extension not available';?> +--FILE-- +<?php +print_r(exif_read_data(__DIR__ . '/bug72094_1.jpg')); +print_r(exif_read_data(__DIR__ . '/bug72094_2.jpg')); +print_r(exif_read_data(__DIR__ . '/bug72094_3.jpg')); +print_r(exif_read_data(__DIR__ . '/bug72094_4.jpg')); +?> +DONE +--EXPECTF-- +Warning: exif_read_data(bug72094_1.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_1.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_1.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_1.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_1.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_1.jpg): Process tag(x8298=Copyright ): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_1.jpg): Illegal IFD offset in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_1.jpg): File structure corrupted in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_1.jpg): Invalid JPEG file in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_2.jpg): Illegal IFD size in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_2.jpg): File structure corrupted in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_2.jpg): Invalid JPEG file in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_3.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_3.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_3.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_3.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_3.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_3.jpg): Process tag(x3030=UndefinedTa): Illegal format code 0x3030, suppose BYTE in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_3.jpg): Illegal IFD size in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_3.jpg): File structure corrupted in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_3.jpg): Invalid JPEG file in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_4.jpg): Invalid TIFF start (1) in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_4.jpg): File structure corrupted in %s%ebug72094.php on line %d + +Warning: exif_read_data(bug72094_4.jpg): Invalid JPEG file in %s%ebug72094.php on line %d +DONE diff --git a/ext/exif/tests/bug72094_1.jpg b/ext/exif/tests/bug72094_1.jpg Binary files differnew file mode 100644 index 0000000000..d21382b44b --- /dev/null +++ b/ext/exif/tests/bug72094_1.jpg diff --git a/ext/exif/tests/bug72094_2.jpg b/ext/exif/tests/bug72094_2.jpg Binary files differnew file mode 100644 index 0000000000..ec414ce02b --- /dev/null +++ b/ext/exif/tests/bug72094_2.jpg diff --git a/ext/exif/tests/bug72094_3.jpg b/ext/exif/tests/bug72094_3.jpg Binary files differnew file mode 100644 index 0000000000..8b05314b67 --- /dev/null +++ b/ext/exif/tests/bug72094_3.jpg diff --git a/ext/exif/tests/bug72094_4.jpg b/ext/exif/tests/bug72094_4.jpg Binary files differnew file mode 100644 index 0000000000..ca6d453c2c --- /dev/null +++ b/ext/exif/tests/bug72094_4.jpg diff --git a/ext/gd/libgd/gd_gd2.c b/ext/gd/libgd/gd_gd2.c index efc6ef47af..6726fee826 100644 --- a/ext/gd/libgd/gd_gd2.c +++ b/ext/gd/libgd/gd_gd2.c @@ -145,9 +145,15 @@ static int _gd2GetHeader(gdIOCtxPtr in, int *sx, int *sy, int *cs, int *vers, in cidx = gdCalloc(sidx, 1); for (i = 0; i < nc; i++) { if (gdGetInt(&cidx[i].offset, in) != 1) { + gdFree(cidx); goto fail1; } if (gdGetInt(&cidx[i].size, in) != 1) { + gdFree(cidx); + goto fail1; + } + if (cidx[i].offset < 0 || cidx[i].size < 0) { + gdFree(cidx); goto fail1; } } diff --git a/ext/gd/tests/bug71912.phpt b/ext/gd/tests/bug71912.phpt new file mode 100644 index 0000000000..c86188b0f2 --- /dev/null +++ b/ext/gd/tests/bug71912.phpt @@ -0,0 +1,16 @@ +--TEST-- +Bug #71912 (libgd: signedness vulnerability) +--SKIPIF-- +<?php + if(!extension_loaded('gd')){ die('skip gd extension not available'); } + if(!function_exists('imagecreatefromgd2')) die('skip imagecreatefromgd2() not available'); +?> +--FILE-- +<?php +imagecreatefromgd2(__DIR__ . DIRECTORY_SEPARATOR . "invalid_neg_size.gd2"); +?> +OK +--EXPECTF-- + +Warning: imagecreatefromgd2(): '%s%einvalid_neg_size.gd2' is not a valid GD2 file in %s%ebug71912.php on line %d +OK diff --git a/ext/gd/tests/bug71952.phpt b/ext/gd/tests/bug71952.phpt new file mode 100644 index 0000000000..f1f66bf26d --- /dev/null +++ b/ext/gd/tests/bug71952.phpt @@ -0,0 +1,14 @@ +--TEST-- +Bug #71952 (Corruption inside imageaffinematrixget) +--SKIPIF-- +<?php + if(!extension_loaded('gd')){ die('skip gd extension not available'); } +?> +--FILE-- +<?php +$vals=[str_repeat("A","200"),0,1,2,3,4,5,6,7,8,9]; +imageaffinematrixget(4,$vals[0]); +var_dump($vals[0]); +?> +--EXPECTF-- +string(200) "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
\ No newline at end of file diff --git a/ext/gd/tests/invalid_neg_size.gd2 b/ext/gd/tests/invalid_neg_size.gd2 Binary files differnew file mode 100644 index 0000000000..3075f15a81 --- /dev/null +++ b/ext/gd/tests/invalid_neg_size.gd2 diff --git a/ext/gmp/gmp.c b/ext/gmp/gmp.c index 56235e0c68..a1e15899c9 100644 --- a/ext/gmp/gmp.c +++ b/ext/gmp/gmp.c @@ -1144,11 +1144,10 @@ ZEND_FUNCTION(gmp_export) } else { size_t bits_per_word = size * 8; size_t count = (mpz_sizeinbase(gmpnumber, 2) + bits_per_word - 1) / bits_per_word; - size_t out_len = count * size; - zend_string *out_string = zend_string_alloc(out_len, 0); + zend_string *out_string = zend_string_safe_alloc(count, size, 0, 0); mpz_export(ZSTR_VAL(out_string), NULL, order, size, endian, 0, gmpnumber); - ZSTR_VAL(out_string)[out_len] = '\0'; + ZSTR_VAL(out_string)[ZSTR_LEN(out_string)] = '\0'; RETURN_NEW_STR(out_string); } diff --git a/ext/interbase/ibase_blobs.c b/ext/interbase/ibase_blobs.c index 70640236c3..3cd649dbf9 100644 --- a/ext/interbase/ibase_blobs.c +++ b/ext/interbase/ibase_blobs.c @@ -99,7 +99,7 @@ int _php_ibase_blob_get(zval *return_value, ibase_blob *ib_blob, zend_ulong max_ zend_ulong cur_len; unsigned short seg_len; - bl_data = zend_string_alloc(max_len, 0); + bl_data = zend_string_safe_alloc(1, max_len, 0, 0); for (cur_len = stat = 0; (stat == 0 || stat == isc_segment) && cur_len < max_len; cur_len += seg_len) { diff --git a/ext/intl/calendar/calendar_class.cpp b/ext/intl/calendar/calendar_class.cpp index 1f3a68b802..574f9a0fc3 100644 --- a/ext/intl/calendar/calendar_class.cpp +++ b/ext/intl/calendar/calendar_class.cpp @@ -177,7 +177,7 @@ static HashTable *Calendar_get_debug_info(zval *object, int *is_temp) HashTable *debug_info_tz; timezone_object_construct(&cal->getTimeZone(), &ztz , 0); - debug_info = Z_OBJ_HANDLER(ztz, get_debug_info)(&ztz, &is_tmp); + debug_info_tz = Z_OBJ_HANDLER(ztz, get_debug_info)(&ztz, &is_tmp); assert(is_tmp == 1); array_init(&ztz_debug); diff --git a/ext/intl/dateformat/dateformat_create.cpp b/ext/intl/dateformat/dateformat_create.cpp index 51ec063270..00a5cc593c 100644 --- a/ext/intl/dateformat/dateformat_create.cpp +++ b/ext/intl/dateformat/dateformat_create.cpp @@ -36,7 +36,7 @@ extern "C" { #include "dateformat_helpers.h" #include "zend_exceptions.h" -#if U_ICU_VERSION_MINOR_NUM < 50 +#if U_ICU_VERSION_MAJOR_NUM < 50 #define UDAT_PATTERN 0 #endif diff --git a/ext/intl/grapheme/grapheme_string.c b/ext/intl/grapheme/grapheme_string.c index 9fb4e35405..0735a7e822 100644 --- a/ext/intl/grapheme/grapheme_string.c +++ b/ext/intl/grapheme/grapheme_string.c @@ -110,7 +110,7 @@ PHP_FUNCTION(grapheme_strpos) size_t haystack_len, needle_len; const char *found; zend_long loffset = 0; - int32_t offset = 0; + int32_t offset = 0, noffset = 0; zend_long ret_pos; if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", &haystack, &haystack_len, &needle, &needle_len, &loffset) == FAILURE) { @@ -126,6 +126,7 @@ PHP_FUNCTION(grapheme_strpos) /* we checked that it will fit: */ offset = (int32_t) loffset; + noffset = offset >= 0 ? offset : haystack_len + offset; /* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */ @@ -138,7 +139,7 @@ PHP_FUNCTION(grapheme_strpos) /* quick check to see if the string might be there * I realize that 'offset' is 'grapheme count offset' but will work in spite of that */ - found = php_memnstr(haystack + offset, needle, needle_len, haystack + haystack_len); + found = php_memnstr(haystack + noffset, needle, needle_len, haystack + haystack_len); /* if it isn't there the we are done */ if (!found) { @@ -199,13 +200,13 @@ PHP_FUNCTION(grapheme_stripos) is_ascii = ( grapheme_ascii_check((unsigned char*)haystack, haystack_len) >= 0 ); if ( is_ascii ) { + int32_t noffset = offset >= 0 ? offset : haystack_len + offset; needle_dup = estrndup(needle, needle_len); php_strtolower(needle_dup, needle_len); haystack_dup = estrndup(haystack, haystack_len); php_strtolower(haystack_dup, haystack_len); - found = php_memnstr(haystack_dup + offset + ((offset < 0) ? haystack_len : 0) - , needle_dup, needle_len, haystack_dup + haystack_len); + found = php_memnstr(haystack_dup + noffset, needle_dup, needle_len, haystack_dup + haystack_len); efree(haystack_dup); efree(needle_dup); diff --git a/ext/intl/msgformat/msgformat_helpers.cpp b/ext/intl/msgformat/msgformat_helpers.cpp index ed63105fa7..ce7899edd9 100644 --- a/ext/intl/msgformat/msgformat_helpers.cpp +++ b/ext/intl/msgformat/msgformat_helpers.cpp @@ -264,6 +264,10 @@ static HashTable *umsg_parse_format(MessageFormatter_object *mfo, type = Formattable::kDouble; } else if (argType == UMSGPAT_ARG_TYPE_SELECT) { type = Formattable::kString; +#if U_ICU_VERSION_MAJOR_NUM >= 50 + } else if (argType == UMSGPAT_ARG_TYPE_SELECTORDINAL) { + type = Formattable::kDouble; +#endif } else { type = Formattable::kString; } diff --git a/ext/intl/tests/bug72061.phpt b/ext/intl/tests/bug72061.phpt new file mode 100644 index 0000000000..782c32c11c --- /dev/null +++ b/ext/intl/tests/bug72061.phpt @@ -0,0 +1,15 @@ +--TEST-- +Bug #72061: Out-of-bounds reads in zif_grapheme_stripos with negative offset +--SKIPIF-- +<?php if( !extension_loaded( 'intl' ) ) print 'skip'; ?> +--FILE-- +<?php + +var_dump(grapheme_stripos(str_repeat("ABCD", 16384), "A", -201)); +var_dump(grapheme_strpos(str_repeat("ABCD", 16384), "A", -201)); +?> +DONE +--EXPECT-- +int(65336) +int(65336) +DONE
\ No newline at end of file diff --git a/ext/intl/tests/msgfmt_bug70484.phpt b/ext/intl/tests/msgfmt_bug70484.phpt new file mode 100644 index 0000000000..9d0bdc4ee8 --- /dev/null +++ b/ext/intl/tests/msgfmt_bug70484.phpt @@ -0,0 +1,97 @@ +--TEST-- +Bug #70484 selectordinal doesn't work with named parameters +--SKIPIF-- +<?php +if (!extension_loaded('intl')) + die('skip intl extension not enabled'); +if (version_compare(INTL_ICU_VERSION, '5.0') < 0) + die('skip for ICU 5.0+'); +--FILE-- +<?php + +$locale = array("de", "fr", "en", "ru",); + +$data = array(42, 42.42, 2147483643, 2147483643.12345, 5); + +foreach ($locale as $lc) { + echo "$lc string key\n"; + $m = new MessageFormatter($lc, "{n, selectordinal, =5 {five} zero {#-zero} one {#-one} two {#-two} few {#-few} many {#-many} other {#-other}}"); + foreach ($data as $i) { + var_dump($m->format(array("n" => $i))); + if ($m->getErrorCode()) { + echo "$lc $i ", $m->getErrorMessage(); + } + } + echo "\n"; + + echo "$lc numeric key\n"; + $m = new MessageFormatter($lc, "{0, selectordinal, =5 {five} zero {#-zero} one {#-one} two {#-two} few {#-few} many {#-many} other {#-other}}"); + foreach ($data as $i) { + var_dump($m->format(array($i))); + if ($m->getErrorCode()) { + echo "$lc $i ", $m->getErrorMessage(); + } + } + echo "\n"; +} + +?> +==DONE== +--EXPECT-- +de string key +string(8) "42-other" +string(11) "42,42-other" +string(19) "2.147.483.643-other" +string(23) "2.147.483.643,123-other" +string(4) "five" + +de numeric key +string(8) "42-other" +string(11) "42,42-other" +string(19) "2.147.483.643-other" +string(23) "2.147.483.643,123-other" +string(4) "five" + +fr string key +string(8) "42-other" +string(11) "42,42-other" +string(22) "2 147 483 643-other" +string(26) "2 147 483 643,123-other" +string(4) "five" + +fr numeric key +string(8) "42-other" +string(11) "42,42-other" +string(22) "2 147 483 643-other" +string(26) "2 147 483 643,123-other" +string(4) "five" + +en string key +string(6) "42-two" +string(11) "42.42-other" +string(17) "2,147,483,643-few" +string(23) "2,147,483,643.123-other" +string(4) "five" + +en numeric key +string(6) "42-two" +string(11) "42.42-other" +string(17) "2,147,483,643-few" +string(23) "2,147,483,643.123-other" +string(4) "five" + +ru string key +string(8) "42-other" +string(11) "42,42-other" +string(22) "2 147 483 643-other" +string(26) "2 147 483 643,123-other" +string(4) "five" + +ru numeric key +string(8) "42-other" +string(11) "42,42-other" +string(22) "2 147 483 643-other" +string(26) "2 147 483 643,123-other" +string(4) "five" + +==DONE== diff --git a/ext/intl/tests/timezone_IDforWindowsID_basic.phpt b/ext/intl/tests/timezone_IDforWindowsID_basic.phpt new file mode 100644 index 0000000000..4127d8e31c --- /dev/null +++ b/ext/intl/tests/timezone_IDforWindowsID_basic.phpt @@ -0,0 +1,46 @@ +--TEST-- +IntlTimeZone::getIDForWindowsID basic test +--SKIPIF-- +<?php +if (!extension_loaded('intl')) + die('skip intl extension not enabled'); +if (version_compare(INTL_ICU_VERSION, '52') < 0) + die('skip for ICU >= 52'); +--FILE-- +<?php + +$tzs = array( + 'Gnomeregan' => array(NULL), + 'India Standard Time' => array(NULL), + 'Pacific Standard Time' => array('001', 'CA', 'MX', 'US', 'ZZ'), + 'Romance Standard Time' => array('001', 'BE', 'DK', 'ES', 'FR'), +); + +foreach ($tzs as $tz => $regions) { + echo "** $tz\n"; + foreach ($regions as $region) { + var_dump(IntlTimeZone::getIDForWindowsID($tz, $region)); + if (intl_get_error_code() != U_ZERO_ERROR) { + echo "Error: ", intl_get_error_message(), "\n"; + } + } +} + +--EXPECT-- +** Gnomeregan +bool(false) +Error: intltz_get_windows_id: Unknown windows timezone: U_ILLEGAL_ARGUMENT_ERROR +** India Standard Time +string(13) "Asia/Calcutta" +** Pacific Standard Time +string(19) "America/Los_Angeles" +string(17) "America/Vancouver" +string(15) "America/Tijuana" +string(19) "America/Los_Angeles" +string(7) "PST8PDT" +** Romance Standard Time +string(12) "Europe/Paris" +string(15) "Europe/Brussels" +string(17) "Europe/Copenhagen" +string(13) "Europe/Madrid" +string(12) "Europe/Paris" diff --git a/ext/intl/tests/timezone_windowsID_basic.phpt b/ext/intl/tests/timezone_windowsID_basic.phpt new file mode 100644 index 0000000000..dd48f016e2 --- /dev/null +++ b/ext/intl/tests/timezone_windowsID_basic.phpt @@ -0,0 +1,43 @@ +--TEST-- +IntlTimeZone::getWindowsID basic test +--SKIPIF-- +<?php +if (!extension_loaded('intl')) + die('skip intl extension not enabled'); +if (version_compare(INTL_ICU_VERSION, '52') < 0) + die('skip for ICU >= 52'); +--FILE-- +<?php + +$tzs = array( + 'America/Bogota', + 'America/Havana', + 'America/Indiana/Knox', + 'America/Los_Angeles', + 'Azeroth/Kalimdor/Durotar', + 'Africa/Casablanca', + 'Asia/Singapore', + 'Australia/Perth', + 'Europe/London', + 'Europe/Istanbul', +); + +foreach ($tzs as $tz) { + var_dump(IntlTimeZone::getWindowsID($tz)); + if (intl_get_error_code() != U_ZERO_ERROR) { + echo "Error: ", intl_get_error_message(), "\n"; + } +} + +--EXPECT-- +string(24) "SA Pacific Standard Time" +string(21) "Eastern Standard Time" +string(21) "Central Standard Time" +string(21) "Pacific Standard Time" +bool(false) +Error: intltz_get_windows_id: Unknown system timezone: U_ILLEGAL_ARGUMENT_ERROR +string(21) "Morocco Standard Time" +string(23) "Singapore Standard Time" +string(26) "W. Australia Standard Time" +string(17) "GMT Standard Time" +string(20) "Turkey Standard Time" diff --git a/ext/intl/timezone/timezone_class.cpp b/ext/intl/timezone/timezone_class.cpp index d1e8e2e0a6..f67e55ae4e 100644 --- a/ext/intl/timezone/timezone_class.cpp +++ b/ext/intl/timezone/timezone_class.cpp @@ -439,6 +439,17 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(ainfo_tz_void, 0, 0, 0) ZEND_END_ARG_INFO() +#if U_ICU_VERSION_MAJOR_NUM >= 52 +ZEND_BEGIN_ARG_INFO_EX(ainfo_tz_getWindowsID, 0, ZEND_RETURN_VALUE, 1) + ZEND_ARG_INFO(0, timezone) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(ainfo_tz_getIDForWindowsID, 0, ZEND_RETURN_VALUE, 1) + ZEND_ARG_INFO(0, timezone) + ZEND_ARG_INFO(0, region) +ZEND_END_ARG_INFO() +#endif + /* }}} */ /* {{{ TimeZone_class_functions @@ -475,6 +486,10 @@ static zend_function_entry TimeZone_class_functions[] = { PHP_ME_MAPPING(toDateTimeZone, intltz_to_date_time_zone, ainfo_tz_void, ZEND_ACC_PUBLIC) PHP_ME_MAPPING(getErrorCode, intltz_get_error_code, ainfo_tz_void, ZEND_ACC_PUBLIC) PHP_ME_MAPPING(getErrorMessage, intltz_get_error_message, ainfo_tz_void, ZEND_ACC_PUBLIC) +#if U_ICU_VERSION_MAJOR_NUM >= 52 + PHP_ME_MAPPING(getWindowsID, intltz_get_windows_id, ainfo_tz_getWindowsID, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) + PHP_ME_MAPPING(getIDForWindowsID, intltz_get_id_for_windows_id, ainfo_tz_getIDForWindowsID, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) +#endif PHP_FE_END }; /* }}} */ diff --git a/ext/intl/timezone/timezone_methods.cpp b/ext/intl/timezone/timezone_methods.cpp index a35174d3da..20c0e02480 100644 --- a/ext/intl/timezone/timezone_methods.cpp +++ b/ext/intl/timezone/timezone_methods.cpp @@ -647,3 +647,81 @@ U_CFUNC PHP_FUNCTION(intltz_get_error_message) message = intl_error_get_message(TIMEZONE_ERROR_P(to)); RETURN_STR(message); } + +#if U_ICU_VERSION_MAJOR_NUM >= 52 +/* {{{ proto string IntlTimeZone::getWindowsID(string $timezone) + proto string intltz_get_windows_id(string $timezone) +Translate a system timezone (e.g. "America/Los_Angeles" into a +Windows Timezone (e.g. "Pacific Standard Time") + */ +U_CFUNC PHP_FUNCTION(intltz_get_windows_id) +{ + zend_string *id, *winID; + UnicodeString uID, uWinID; + UErrorCode error; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &id) == FAILURE) { + return; + } + + error = U_ZERO_ERROR; + if (intl_stringFromChar(uID, id->val, id->len, &error) == FAILURE) { + intl_error_set(NULL, error, + "intltz_get_windows_id: could not convert time zone id to UTF-16", 0); + RETURN_FALSE; + } + + error = U_ZERO_ERROR; + TimeZone::getWindowsID(uID, uWinID, error); + INTL_CHECK_STATUS(error, "intltz_get_windows_id: Unable to get timezone from windows ID"); + if (uWinID.length() == 0) { + intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, + "intltz_get_windows_id: Unknown system timezone", 0); + RETURN_FALSE; + } + + error = U_ZERO_ERROR; + winID = intl_convert_utf16_to_utf8(uWinID.getBuffer(), uWinID.length(), &error); + INTL_CHECK_STATUS(error, "intltz_get_windows_id: could not convert time zone id to UTF-8"); + RETURN_STR(winID); +} +/* }}} */ + +/* {{{ proto string IntlTimeZone::getIDForWindowsID(string $timezone[, string $region = NULL]) + proto string intltz_get_id_for_windows_id(string $timezone[, string $region = NULL]) +Translate a windows timezone (e.g. "Pacific Time Zone" into a +System Timezone (e.g. "America/Los_Angeles") + */ +U_CFUNC PHP_FUNCTION(intltz_get_id_for_windows_id) +{ + zend_string *winID, *region = NULL, *id; + UnicodeString uWinID, uID; + UErrorCode error; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|S", &winID, ®ion) == FAILURE) { + return; + } + + error = U_ZERO_ERROR; + if (intl_stringFromChar(uWinID, winID->val, winID->len, &error) == FAILURE) { + intl_error_set(NULL, error, + "intltz_get_id_for_windows_id: could not convert time zone id to UTF-16", 0); + RETURN_FALSE; + } + + error = U_ZERO_ERROR; + TimeZone::getIDForWindowsID(uWinID, region ? region->val : NULL, uID, error); + INTL_CHECK_STATUS(error, "intltz_get_id_for_windows_id: Unable to get windows ID for timezone"); + if (uID.length() == 0) { + intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, + "intltz_get_windows_id: Unknown windows timezone", 0); + RETURN_FALSE; + } + + error = U_ZERO_ERROR; + id = intl_convert_utf16_to_utf8(uID.getBuffer(), uID.length(), &error); + INTL_CHECK_STATUS(error, "intltz_get_id_for_windows_id: could not convert time zone id to UTF-8"); + RETURN_STR(id); +} +/* }}} */ +#endif diff --git a/ext/intl/timezone/timezone_methods.h b/ext/intl/timezone/timezone_methods.h index 29d72913fd..6e6fa3f472 100644 --- a/ext/intl/timezone/timezone_methods.h +++ b/ext/intl/timezone/timezone_methods.h @@ -65,4 +65,9 @@ PHP_FUNCTION(intltz_get_error_code); PHP_FUNCTION(intltz_get_error_message); +#if U_ICU_VERSION_MAJOR_NUM >= 52 +PHP_FUNCTION(intltz_get_windows_id); +PHP_FUNCTION(intltz_get_id_for_windows_id); +#endif + #endif /* #ifndef TIMEZONE_METHODS_H */ diff --git a/ext/intl/transliterator/transliterator_class.c b/ext/intl/transliterator/transliterator_class.c index ce8c7e6291..5c80b25af8 100644 --- a/ext/intl/transliterator/transliterator_class.c +++ b/ext/intl/transliterator/transliterator_class.c @@ -269,9 +269,15 @@ static zval *Transliterator_read_property( zval *object, zval *member, int type, static void Transliterator_write_property( zval *object, zval *member, zval *value, void **cache_slot ) { + zend_class_entry *scope; TRANSLITERATOR_PROPERTY_HANDLER_PROLOG; - if( ( EG( scope ) != Transliterator_ce_ptr ) && + if (EG(fake_scope)) { + scope = EG(fake_scope); + } else { + scope = zend_get_executed_scope(); + } + if( ( scope != Transliterator_ce_ptr ) && ( zend_binary_strcmp( "id", sizeof( "id" ) - 1, Z_STRVAL_P( member ), Z_STRLEN_P( member ) ) == 0 ) ) { diff --git a/ext/json/json.c b/ext/json/json.c index bd7c0b0c1b..d3c6111d4d 100644 --- a/ext/json/json.c +++ b/ext/json/json.c @@ -254,7 +254,7 @@ static PHP_FUNCTION(json_decode) return; } - JSON_G(error_code) = 0; + JSON_G(error_code) = PHP_JSON_ERROR_NONE; if (!str_len) { JSON_G(error_code) = PHP_JSON_ERROR_SYNTAX; diff --git a/ext/json/json_encoder.c b/ext/json/json_encoder.c index 8da5abd088..62df102847 100644 --- a/ext/json/json_encoder.c +++ b/ext/json/json_encoder.c @@ -457,6 +457,7 @@ static void php_json_encode_serializable_object(smart_str *buf, zval *val, int o zend_class_entry *ce = Z_OBJCE_P(val); zval retval, fname; HashTable* myht; + int origin_error_code; if (Z_TYPE_P(val) == IS_ARRAY) { myht = Z_ARRVAL_P(val); @@ -470,8 +471,10 @@ static void php_json_encode_serializable_object(smart_str *buf, zval *val, int o return; } + ZVAL_STRING(&fname, "jsonSerialize"); + origin_error_code = JSON_G(error_code); if (FAILURE == call_user_function_ex(EG(function_table), val, &fname, &retval, 0, NULL, 1, NULL) || Z_TYPE(retval) == IS_UNDEF) { zend_throw_exception_ex(NULL, 0, "Failed calling %s::jsonSerialize()", ZSTR_VAL(ce->name)); smart_str_appendl(buf, "null", sizeof("null") - 1); @@ -479,6 +482,7 @@ static void php_json_encode_serializable_object(smart_str *buf, zval *val, int o return; } + JSON_G(error_code) = origin_error_code; if (EG(exception)) { /* Error already raised */ zval_ptr_dtor(&retval); diff --git a/ext/json/tests/bug72069.phpt b/ext/json/tests/bug72069.phpt new file mode 100644 index 0000000000..0ff8c98621 --- /dev/null +++ b/ext/json/tests/bug72069.phpt @@ -0,0 +1,29 @@ +--TEST-- +Bug #72069 (Behavior \JsonSerializable different from json_encode) +--SKIPIF-- +<?php if (!extension_loaded("json")) print "skip"; ?> +--FILE-- +<?php + +$result = json_encode(['end' => json_decode(null, true)]); +var_dump($result); + +class A implements \JsonSerializable +{ + function jsonSerialize() + { + return ['end' => json_decode(null, true)]; + } +} +$a = new A(); +$toJsonData = $a->jsonSerialize(); +$result = json_encode($a); +var_dump($result); + +$result = json_encode($toJsonData); +var_dump($result); +?> +--EXPECT-- +string(12) "{"end":null}" +string(12) "{"end":null}" +string(12) "{"end":null}" diff --git a/ext/mysqli/mysqli.c b/ext/mysqli/mysqli.c index 7d971c1b99..a907eed42f 100644 --- a/ext/mysqli/mysqli.c +++ b/ext/mysqli/mysqli.c @@ -1282,7 +1282,6 @@ void php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAMETERS, int override_flags if (ce->constructor) { fci.size = sizeof(fci); - fci.function_table = &ce->function_table; ZVAL_UNDEF(&fci.function_name); fci.object = Z_OBJ_P(return_value); fci.retval = &retval; @@ -1308,7 +1307,7 @@ void php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAMETERS, int override_flags fcc.initialized = 1; fcc.function_handler = ce->constructor; - fcc.calling_scope = EG(scope); + fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = Z_OBJCE_P(return_value); fcc.object = Z_OBJ_P(return_value); diff --git a/ext/oci8/oci8_dtrace.d b/ext/oci8/oci8_dtrace.d index 30c98de912..c8b5dfcfc3 100644 --- a/ext/oci8/oci8_dtrace.d +++ b/ext/oci8/oci8_dtrace.d @@ -4,11 +4,11 @@ +----------------------------------------------------------------------+ | Copyright (c) 2013 Zend Technologies Ltd. (http://www.zend.com) | +----------------------------------------------------------------------+ - | This source file is subject to version 3.01 of the Zend license, | + | This source file is subject to version 3.01 of the PHP 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/3_01.txt. | - | If you did not receive a copy of the Zend license and are unable to | + | http://www.php.net/license/3_01.txt. | + | If you did not receive a copy of the PHP 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. | +----------------------------------------------------------------------+ diff --git a/ext/oci8/oci8_interface.c b/ext/oci8/oci8_interface.c index e3bd509216..bb8828b746 100644 --- a/ext/oci8/oci8_interface.c +++ b/ext/oci8/oci8_interface.c @@ -1380,15 +1380,17 @@ PHP_FUNCTION(oci_fetch_all) PHP_OCI_ZVAL_TO_STATEMENT(z_statement, statement); zval_dtor(array); - array_init(array); while (skip--) { if (php_oci_statement_fetch(statement, nrows)) { + array_init(array); RETURN_LONG(0); } } if (flags & PHP_OCI_FETCHSTATEMENT_BY_ROW) { + /* Fetch by Row: array will contain one sub-array per query row */ + array_init(array); columns = safe_emalloc(statement->ncolumns, sizeof(php_oci_out_column *), 0); for (i = 0; i < statement->ncolumns; i++) { @@ -1398,7 +1400,7 @@ PHP_FUNCTION(oci_fetch_all) while (!php_oci_statement_fetch(statement, nrows)) { zval row; - array_init(&row); + array_init_size(&row, statement->ncolumns); for (i = 0; i < statement->ncolumns; i++) { php_oci_column_to_zval(columns[ i ], &element, PHP_OCI_RETURN_LOBS); @@ -1409,7 +1411,7 @@ PHP_FUNCTION(oci_fetch_all) zend_string *zvtmp; zvtmp = zend_string_init(columns[ i ]->name, columns[ i ]->name_len, 0); zend_symtable_update(Z_ARRVAL(row), zvtmp, &element); - zend_string_release(zvtmp); + zend_string_release(zvtmp); } } @@ -1424,6 +1426,8 @@ PHP_FUNCTION(oci_fetch_all) efree(columns); } else { /* default to BY_COLUMN */ + /* Fetch by columns: array will contain one sub-array per query column */ + array_init_size(array, statement->ncolumns); columns = safe_emalloc(statement->ncolumns, sizeof(php_oci_out_column *), 0); outarrs = safe_emalloc(statement->ncolumns, sizeof(zval*), 0); @@ -1440,9 +1444,9 @@ PHP_FUNCTION(oci_fetch_all) columns[ i ] = php_oci_statement_get_column(statement, i + 1, NULL, 0); array_init(&tmp); - zvtmp = zend_string_init(columns[ i ]->name, columns[ i ]->name_len, 0); + zvtmp = zend_string_init(columns[ i ]->name, columns[ i ]->name_len, 0); outarrs[ i ] = zend_symtable_update(Z_ARRVAL_P(array), zvtmp, &tmp); - zend_string_release(zvtmp); + zend_string_release(zvtmp); } } diff --git a/ext/oci8/oci8_statement.c b/ext/oci8/oci8_statement.c index 5fc21c2fbd..55983d3e9f 100644 --- a/ext/oci8/oci8_statement.c +++ b/ext/oci8/oci8_statement.c @@ -1149,7 +1149,8 @@ int php_oci_bind_by_name(php_oci_statement *statement, char *name, size_t name_l return 1; } convert_to_long(var); -#if defined(OCI_MAJOR_VERSION) && OCI_MAJOR_VERSION > 10 +#if defined(OCI_MAJOR_VERSION) && (OCI_MAJOR_VERSION > 10) && \ + (defined(__x86_64__) || defined(__LP64__) || defined(_LP64) || defined(_WIN64)) bind_data = (ub8 *)&Z_LVAL_P(var); value_sz = sizeof(ub8); #else diff --git a/ext/oci8/package.xml b/ext/oci8/package.xml index a672e29671..88462415cb 100644 --- a/ext/oci8/package.xml +++ b/ext/oci8/package.xml @@ -9,7 +9,7 @@ http://pear.php.net/dtd/package-2.0.xsd"> <description> Use the OCI8 extension to access Oracle Database. PHP OCI8 2.1 builds -with PHP 7. Use 'pecl install oci8-2.0.10' to install OCI8 for PHP +with PHP 7. Use 'pecl install oci8-2.0.11' to install OCI8 for PHP 5.2 - PHP 5.6. Use 'pecl install oci8-1.4.10' to install PHP OCI8 1.4 for PHP 4.3.9 - PHP 5.1. The OCI8 extension can be linked with Oracle client libraries from Oracle Database 12.1, 11, or 10.2. These @@ -46,12 +46,12 @@ Interoperability Support" (ID 207303.1) for details. <active>no</active> </lead> - <date>2015-12-12</date> + <date>2016-04-15</date> <time>12:00:00</time> <version> - <release>2.1.0</release> - <api>2.1.0</api> + <release>2.1.1</release> + <api>2.1.1</api> </version> <stability> <release>stable</release> @@ -60,7 +60,7 @@ Interoperability Support" (ID 207303.1) for details. <license uri="http://www.php.net/license">PHP</license> <notes> This version is for PHP 7 only. -Updated driver name format. +Fixed bug #71600 (oci_fetch_all segfaults when selecting more than 8 columns) </notes> <contents> <dir name="/"> @@ -161,6 +161,8 @@ Updated driver name format. <file name="bug51291_1.phpt" role="test" /> <file name="bug51291_2.phpt" role="test" /> <file name="bug68298.phpt" role="test" /> + <file name="bug71422.phpt" role="test" /> + <file name="bug71600.phpt" role="test" /> <file name="clientversion.phpt" role="test" /> <file name="close.phpt" role="test" /> <file name="coll_001.phpt" role="test" /> @@ -467,6 +469,37 @@ Updated driver name format. <release> <version> + <release>2.1.0</release> + <api>2.1.0</api> + </version> + <stability> + <release>stable</release> + <api>stable</api> + </stability> + <license uri="http://www.php.net/license">PHP</license> + <notes> +This version is for PHP 7 only. +Updated driver name format. + </notes> +</release> + +<release> + <version> + <release>2.0.10</release> + <api>2.0.10</api> + </version> + <stability> + <release>stable</release> + <api>stable</api> + </stability> + <license uri="http://www.php.net/license">PHP</license> + <notes> +Fixed bug #68298 (OCI int overflow) + </notes> +</release> + +<release> + <version> <release>2.0.9</release> <api>2.0.9</api> </version> diff --git a/ext/oci8/php_oci8.h b/ext/oci8/php_oci8.h index 7f1fba0353..da62aabac6 100644 --- a/ext/oci8/php_oci8.h +++ b/ext/oci8/php_oci8.h @@ -45,7 +45,7 @@ */ #undef PHP_OCI8_VERSION #endif -#define PHP_OCI8_VERSION "2.1.0" +#define PHP_OCI8_VERSION "2.1.1" extern zend_module_entry oci8_module_entry; #define phpext_oci8_ptr &oci8_module_entry diff --git a/ext/oci8/tests/bug71422.phpt b/ext/oci8/tests/bug71422.phpt new file mode 100644 index 0000000000..5978e04ece --- /dev/null +++ b/ext/oci8/tests/bug71422.phpt @@ -0,0 +1,65 @@ +--TEST-- +Bug #71422 (Fix ORA-01438: value larger than specified precision allowed for this column) +--SKIPIF-- +<?php +if (!extension_loaded('oci8')) die ("skip no oci8 extension"); +?> +--FILE-- +<?php + +require(dirname(__FILE__).'/connect.inc'); + +$stmtarray = array( + "DROP TABLE BUG71422_TEST", + "CREATE TABLE BUG71422_TEST (TEST_ID NUMBER(*,0) NOT NULL, LABEL VARCHAR2(50 CHAR), CONSTRAINT BUG71422_TEST_PK PRIMARY KEY (TEST_ID))", + "INSERT INTO BUG71422_TEST (TEST_ID, LABEL) VALUES (1, 'Foo')" +); + +oci8_test_sql_execute($c, $stmtarray); + +$stmt = oci_parse($c, 'SELECT LABEL AS RAW_QUERY FROM BUG71422_TEST WHERE TEST_ID=1'); +oci_execute($stmt); +while ($row = oci_fetch_array($stmt, OCI_ASSOC+OCI_RETURN_NULLS)) { + var_dump($row); +} + +$stmt = oci_parse($c, 'SELECT LABEL AS NUMERIC_BIND_PARAMETER FROM BUG71422_TEST WHERE TEST_ID=:test_id'); +$value = 1; +oci_bind_by_name($stmt, ':test_id', $value, -1, SQLT_INT); +oci_execute($stmt); +while ($row = oci_fetch_array($stmt, OCI_ASSOC+OCI_RETURN_NULLS)) { + var_dump($row); +} + +$stmt = oci_parse($c, 'SELECT LABEL AS STRING_BIND_PARAMETER FROM BUG71422_TEST WHERE TEST_ID=:test_id'); +$value = 1; +oci_bind_by_name($stmt, ':test_id', $value, -1, SQLT_CHR); +oci_execute($stmt); +while ($row = oci_fetch_array($stmt, OCI_ASSOC+OCI_RETURN_NULLS)) { + var_dump($row); +} + +// Cleanup + +$stmtarray = array( + "DROP TABLE BUG71422_TEST" +); +oci8_test_sql_execute($c, $stmtarray); + +?> +===DONE=== +<?php exit(0); ?> +--EXPECTF-- +array(1) { + ["RAW_QUERY"]=> + string(3) "Foo" +} +array(1) { + ["NUMERIC_BIND_PARAMETER"]=> + string(3) "Foo" +} +array(1) { + ["STRING_BIND_PARAMETER"]=> + string(3) "Foo" +} +===DONE=== diff --git a/ext/oci8/tests/bug71600.phpt b/ext/oci8/tests/bug71600.phpt new file mode 100644 index 0000000000..102c59f81a --- /dev/null +++ b/ext/oci8/tests/bug71600.phpt @@ -0,0 +1,96 @@ +--TEST-- +Bug #71600 (oci_fetch_all result in segfault when select more than 8 columns) +--SKIPIF-- +<?php +$target_dbs = array('oracledb' => true, 'timesten' => true); // test runs on these DBs +require(dirname(__FILE__).'/skipif.inc'); +?> +--FILE-- +<?php + +require(dirname(__FILE__).'/connect.inc'); + +// Initialize + +$stmtarray = array( + "create table bug71600_tab (col1 number, col2 number, col3 number, + col4 number, col5 number, col6 number, + col7 number, col8 number, col9 number)", + "insert into bug71600_tab values(1, 2, 3, 4, 5, 6, 7, 8, 9)", + "insert into bug71600_tab values(11, 12, 13, 14, 15, 16, 17, 18, 19)" +); + +oci8_test_sql_execute($c, $stmtarray); + +// Run test + +$sql = "select col1,col2,col3,col4,col5,col6,col7,col8,col9 from bug71600_tab"; + +echo "Test 1\n"; +$stmt = oci_parse($c, $sql); + +echo "Executing SELECT statament...\n"; +oci_execute($stmt,OCI_DEFAULT); + +echo "Fetching data by columns...\n"; +oci_fetch_all($stmt, $result); +oci_free_statement($stmt); + +$rsRows=(count($result,1)/($rows = count($result,0)))-1; +echo "$rsRows Records Found\n"; +$rsCount=0; +while($rsCount < $rsRows) +{ + $col1 =$result['COL1'][$rsCount]; + $col9 =$result['COL9'][$rsCount]; + echo "$rsCount|$col1|$col9\n"; + $rsCount++; +} + +echo "Test 2\n"; +$stmt = oci_parse($c, $sql); + +echo "Re-executing SELECT statament...\n"; +oci_execute($stmt,OCI_DEFAULT); + +echo "Fetching data by rows...\n"; +oci_fetch_all($stmt, $result, 0, -1, OCI_FETCHSTATEMENT_BY_ROW); +oci_free_statement($stmt); + +$rsRows=count($result,0); +echo "$rsRows Records Found\n"; +$rsCount=0; +while($rsCount < $rsRows) +{ + $col1 = $result[$rsCount]['COL1']; + $col9 = $result[$rsCount]['COL9']; + echo "$rsCount|$col1|$col9\n"; + $rsCount++; +} + + +// Cleanup + +$stmtarray = array( + "drop table bug71600_tab" +); + +oci8_test_sql_execute($c, $stmtarray); + +?> +===DONE=== +<?php exit(0); ?> +--EXPECT-- +Test 1 +Executing SELECT statament... +Fetching data by columns... +2 Records Found +0|1|9 +1|11|19 +Test 2 +Re-executing SELECT statament... +Fetching data by rows... +2 Records Found +0|1|9 +1|11|19 +===DONE=== diff --git a/ext/oci8/tests/driver_name.phpt b/ext/oci8/tests/driver_name.phpt index 758e3979a7..0ff9bc485f 100644 --- a/ext/oci8/tests/driver_name.phpt +++ b/ext/oci8/tests/driver_name.phpt @@ -57,11 +57,11 @@ function get_attr($conn) ?> --EXPECT-- **Test 1.1 - Default values for the attribute ************** -The value of DRIVER_NAME is PHP OCI8 : 2.1.0 +The value of DRIVER_NAME is PHP OCI8 : 2.1.1 ***Test 1.2 - Get the values from different connections ************** Testing with oci_pconnect() -The value of DRIVER_NAME is PHP OCI8 : 2.1.0 +The value of DRIVER_NAME is PHP OCI8 : 2.1.1 Testing with oci_new_connect() -The value of DRIVER_NAME is PHP OCI8 : 2.1.0 +The value of DRIVER_NAME is PHP OCI8 : 2.1.1 Done diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c index 0ecb57e2b9..8599d9ba19 100644 --- a/ext/opcache/Optimizer/block_pass.c +++ b/ext/opcache/Optimizer/block_pass.c @@ -690,7 +690,6 @@ optimize_constant_binary_op: opline++; continue; } - printf("%d\n", opline->opcode); er = EG(error_reporting); EG(error_reporting) = 0; if (binary_op(&result, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline)) == SUCCESS) { diff --git a/ext/opcache/Optimizer/optimize_func_calls.c b/ext/opcache/Optimizer/optimize_func_calls.c index 8af82e4137..b37e0fee57 100644 --- a/ext/opcache/Optimizer/optimize_func_calls.c +++ b/ext/opcache/Optimizer/optimize_func_calls.c @@ -59,37 +59,13 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) switch (opline->opcode) { case ZEND_INIT_FCALL_BY_NAME: case ZEND_INIT_NS_FCALL_BY_NAME: - if (ZEND_OP2_IS_CONST_STRING(opline)) { - zend_function *func; - zval *function_name = &ZEND_OP2_LITERAL(opline) + 1; - if ((func = zend_hash_find_ptr(&ctx->script->function_table, - Z_STR_P(function_name))) != NULL) { - call_stack[call].func = func; - } - } - call_stack[call].opline = opline; - call++; - break; case ZEND_INIT_STATIC_METHOD_CALL: - if (ZEND_OP2_IS_CONST_STRING(opline)) { - zend_class_entry *ce = NULL; - if (ZEND_OP1_IS_CONST_STRING(opline)) { - zend_string *class_name = Z_STR_P(&ZEND_OP1_LITERAL(opline) + 1); - ce = zend_hash_find_ptr(&ctx->script->class_table, class_name); - } else if (opline->op1_type == IS_UNUSED && op_array->scope - && !(op_array->scope->ce_flags & ZEND_ACC_TRAIT) - && (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) { - ce = op_array->scope; - } - if (ce) { - zend_string *func_name = Z_STR_P(&ZEND_OP2_LITERAL(opline) + 1); - call_stack[call].func = zend_hash_find_ptr(&ce->function_table, func_name); - } - } + case ZEND_INIT_METHOD_CALL: + call_stack[call].func = zend_optimizer_get_called_func( + ctx->script, op_array, opline, 0); /* break missing intentionally */ case ZEND_NEW: case ZEND_INIT_DYNAMIC_CALL: - case ZEND_INIT_METHOD_CALL: case ZEND_INIT_FCALL: case ZEND_INIT_USER_CALL: call_stack[call].opline = opline; @@ -109,7 +85,7 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) Z_CACHE_SLOT(op_array->literals[fcall->op2.constant + 1]) = Z_CACHE_SLOT(op_array->literals[fcall->op2.constant]); literal_dtor(&ZEND_OP2_LITERAL(fcall)); fcall->op2.constant = fcall->op2.constant + 1; - opline->opcode = zend_get_call_op(ZEND_INIT_FCALL, call_stack[call].func); + opline->opcode = zend_get_call_op(fcall, call_stack[call].func); } else if (fcall->opcode == ZEND_INIT_NS_FCALL_BY_NAME) { fcall->opcode = ZEND_INIT_FCALL; fcall->op1.num = zend_vm_calc_used_stack(fcall->extended_value, call_stack[call].func); @@ -117,8 +93,9 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) literal_dtor(&op_array->literals[fcall->op2.constant]); literal_dtor(&op_array->literals[fcall->op2.constant + 2]); fcall->op2.constant = fcall->op2.constant + 1; - opline->opcode = zend_get_call_op(ZEND_INIT_FCALL, call_stack[call].func); - } else if (fcall->opcode == ZEND_INIT_STATIC_METHOD_CALL) { + opline->opcode = zend_get_call_op(fcall, call_stack[call].func); + } else if (fcall->opcode == ZEND_INIT_STATIC_METHOD_CALL + || fcall->opcode == ZEND_INIT_METHOD_CALL) { /* We don't have specialized opcodes for this, do nothing */ } else { ZEND_ASSERT(0); diff --git a/ext/opcache/Optimizer/zend_call_graph.c b/ext/opcache/Optimizer/zend_call_graph.c index ef586e12a7..f245d14eaa 100644 --- a/ext/opcache/Optimizer/zend_call_graph.c +++ b/ext/opcache/Optimizer/zend_call_graph.c @@ -21,6 +21,8 @@ #include "php.h" #include "zend_compile.h" #include "zend_extensions.h" +#include "Optimizer/zend_optimizer.h" +#include "zend_optimizer_internal.h" #include "zend_inference.h" #include "zend_call_graph.h" #include "zend_func_info.h" @@ -150,39 +152,32 @@ static int zend_analyze_calls(zend_arena **arena, zend_script *script, uint32_t call_info = NULL; switch (opline->opcode) { case ZEND_INIT_FCALL: - if ((func = zend_hash_find_ptr(&script->function_table, Z_STR_P(CRT_CONSTANT(opline->op2)))) != NULL) { - zend_func_info *callee_func_info = ZEND_FUNC_INFO(&func->op_array); - if (callee_func_info) { - call_info = zend_arena_calloc(arena, 1, sizeof(zend_call_info) + (sizeof(zend_send_arg_info) * ((int)opline->extended_value - 1))); - call_info->caller_op_array = op_array; - call_info->caller_init_opline = opline; - call_info->caller_call_opline = NULL; - call_info->callee_func = func; - call_info->num_args = opline->extended_value; - call_info->next_caller = callee_func_info->caller_info; - callee_func_info->caller_info = call_info; - call_info->next_callee = func_info->callee_info; - func_info->callee_info = call_info; - } - } else if ((func = zend_hash_find_ptr(EG(function_table), Z_STR_P(CRT_CONSTANT(opline->op2)))) != NULL && - func->type == ZEND_INTERNAL_FUNCTION) { + case ZEND_INIT_METHOD_CALL: + case ZEND_INIT_STATIC_METHOD_CALL: + func = zend_optimizer_get_called_func( + script, op_array, opline, (build_flags & ZEND_RT_CONSTANTS) != 0); + if (func) { call_info = zend_arena_calloc(arena, 1, sizeof(zend_call_info) + (sizeof(zend_send_arg_info) * ((int)opline->extended_value - 1))); call_info->caller_op_array = op_array; call_info->caller_init_opline = opline; call_info->caller_call_opline = NULL; call_info->callee_func = func; call_info->num_args = opline->extended_value; - call_info->next_caller = NULL; call_info->next_callee = func_info->callee_info; func_info->callee_info = call_info; + + if (func->type == ZEND_INTERNAL_FUNCTION) { + call_info->next_caller = NULL; + } else { + zend_func_info *callee_func_info = ZEND_FUNC_INFO(&func->op_array); + call_info->next_caller = callee_func_info->caller_info; + } } /* break missing intentionally */ case ZEND_INIT_FCALL_BY_NAME: case ZEND_INIT_NS_FCALL_BY_NAME: case ZEND_INIT_DYNAMIC_CALL: case ZEND_NEW: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: case ZEND_INIT_USER_CALL: call_stack[call] = call_info; call++; diff --git a/ext/opcache/Optimizer/zend_dfg.c b/ext/opcache/Optimizer/zend_dfg.c index b45aac41fb..c1972128d5 100644 --- a/ext/opcache/Optimizer/zend_dfg.c +++ b/ext/opcache/Optimizer/zend_dfg.c @@ -25,21 +25,19 @@ int zend_build_dfg(const zend_op_array *op_array, const zend_cfg *cfg, zend_dfg int set_size; zend_basic_block *blocks = cfg->blocks; int blocks_count = cfg->blocks_count; - zend_bitset tmp, gen, def, use, in, out; + zend_bitset tmp, def, use, in, out; zend_op *opline; uint32_t k, var_num; int j; - /* FIXME: can we use "gen" instead of "def" for flow analyzing? */ set_size = dfg->size; tmp = dfg->tmp; - gen = dfg->gen; def = dfg->def; use = dfg->use; in = dfg->in; out = dfg->out; - /* Collect "gen", "def" and "use" sets */ + /* Collect "def" and "use" sets */ for (j = 0; j < blocks_count; j++) { if ((blocks[j].flags & ZEND_BB_REACHABLE) == 0) { continue; @@ -84,6 +82,9 @@ int zend_build_dfg(const zend_op_array *op_array, const zend_cfg *cfg, zend_dfg goto op1_def; } goto op1_use; + case ZEND_UNSET_VAR: + ZEND_ASSERT(opline->extended_value & ZEND_QUICK_SET); + /* break missing intentionally */ case ZEND_ASSIGN: case ZEND_ASSIGN_REF: case ZEND_BIND_GLOBAL: @@ -92,17 +93,6 @@ int zend_build_dfg(const zend_op_array *op_array, const zend_cfg *cfg, zend_dfg case ZEND_SEND_REF: case ZEND_SEND_VAR_NO_REF: case ZEND_FE_RESET_RW: -op1_def: - if (!DFG_ISSET(use, set_size, j, var_num)) { - // FIXME: include into "use" to ...? - DFG_SET(use, set_size, j, var_num); - DFG_SET(def, set_size, j, var_num); - } - DFG_SET(gen, set_size, j, var_num); - break; - case ZEND_UNSET_VAR: - ZEND_ASSERT(opline->extended_value & ZEND_QUICK_SET); - /* break missing intentionally */ case ZEND_ASSIGN_ADD: case ZEND_ASSIGN_SUB: case ZEND_ASSIGN_MUL: @@ -132,7 +122,11 @@ op1_def: case ZEND_FETCH_OBJ_FUNC_ARG: case ZEND_FETCH_OBJ_UNSET: case ZEND_VERIFY_RETURN_TYPE: - DFG_SET(gen, set_size, j, var_num); +op1_def: + // FIXME: include into "use" too ...? + DFG_SET(use, set_size, j, var_num); + DFG_SET(def, set_size, j, var_num); + break; default: op1_use: if (!DFG_ISSET(def, set_size, j, var_num)) { @@ -142,9 +136,9 @@ op1_use: } else if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) { var_num = EX_VAR_TO_NUM(opline->op1.var); if (opline->opcode == ZEND_VERIFY_RETURN_TYPE) { - DFG_SET(gen, set_size, j, var_num); - } - if (!DFG_ISSET(def, set_size, j, var_num)) { + DFG_SET(use, set_size, j, var_num); + DFG_SET(def, set_size, j, var_num); + } else if (!DFG_ISSET(def, set_size, j, var_num)) { DFG_SET(use, set_size, j, var_num); } } @@ -165,12 +159,9 @@ op1_use: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: op2_def: - if (!DFG_ISSET(use, set_size, j, var_num)) { - // FIXME: include into "use" to ...? - DFG_SET(use, set_size, j, var_num); - DFG_SET(def, set_size, j, var_num); - } - DFG_SET(gen, set_size, j, var_num); + // FIXME: include into "use" too ...? + DFG_SET(use, set_size, j, var_num); + DFG_SET(def, set_size, j, var_num); break; default: op2_use: @@ -182,10 +173,7 @@ op2_use: } else if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) { var_num = EX_VAR_TO_NUM(opline->op2.var); if (opline->opcode == ZEND_FE_FETCH_R || opline->opcode == ZEND_FE_FETCH_RW) { - if (!DFG_ISSET(use, set_size, j, var_num)) { - DFG_SET(def, set_size, j, var_num); - } - DFG_SET(gen, set_size, j, var_num); + DFG_SET(def, set_size, j, var_num); } else { if (!DFG_ISSET(def, set_size, j, var_num)) { DFG_SET(use, set_size, j, var_num); @@ -194,10 +182,7 @@ op2_use: } if (opline->result_type & (IS_CV|IS_VAR|IS_TMP_VAR)) { var_num = EX_VAR_TO_NUM(opline->result.var); - if (!DFG_ISSET(use, set_size, j, var_num)) { - DFG_SET(def, set_size, j, var_num); - } - DFG_SET(gen, set_size, j, var_num); + DFG_SET(def, set_size, j, var_num); } } } diff --git a/ext/opcache/Optimizer/zend_dfg.h b/ext/opcache/Optimizer/zend_dfg.h index 9d864992ca..5ed8cfc5d0 100644 --- a/ext/opcache/Optimizer/zend_dfg.h +++ b/ext/opcache/Optimizer/zend_dfg.h @@ -26,7 +26,6 @@ typedef struct _zend_dfg { int vars; uint32_t size; zend_bitset tmp; - zend_bitset gen; zend_bitset def; zend_bitset use; zend_bitset in; diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c index ba5fb8a0ce..986e470345 100644 --- a/ext/opcache/Optimizer/zend_dump.c +++ b/ext/opcache/Optimizer/zend_dump.c @@ -1143,7 +1143,6 @@ void zend_dump_dfg(const zend_op_array *op_array, const zend_cfg *cfg, const zen for (j = 0; j < cfg->blocks_count; j++) { fprintf(stderr, " BB%d:\n", j); - zend_dump_var_set(op_array, "gen", DFG_BITSET(dfg->gen, dfg->size, j)); zend_dump_var_set(op_array, "def", DFG_BITSET(dfg->def, dfg->size, j)); zend_dump_var_set(op_array, "use", DFG_BITSET(dfg->use, dfg->size, j)); zend_dump_var_set(op_array, "in ", DFG_BITSET(dfg->in, dfg->size, j)); diff --git a/ext/opcache/Optimizer/zend_func_info.c b/ext/opcache/Optimizer/zend_func_info.c index 2aa3ecb928..a684a16e73 100644 --- a/ext/opcache/Optimizer/zend_func_info.c +++ b/ext/opcache/Optimizer/zend_func_info.c @@ -529,7 +529,7 @@ static const func_info_t func_infos[] = { F1("forward_static_call", UNKNOWN_INFO), F1("forward_static_call_array", UNKNOWN_INFO), F1("serialize", MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING), - FX("unserialize", UNKNOWN_INFO), + FN("unserialize", UNKNOWN_INFO), F1("var_dump", MAY_BE_NULL), F1("var_export", MAY_BE_NULL | MAY_BE_STRING), F1("debug_zval_dump", MAY_BE_NULL), diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c index 38a278d85d..b853a2e55c 100644 --- a/ext/opcache/Optimizer/zend_inference.c +++ b/ext/opcache/Optimizer/zend_inference.c @@ -2888,7 +2888,7 @@ static void zend_update_type_info(const zend_op_array *op_array, case ZEND_POST_INC: case ZEND_POST_DEC: if (ssa_ops[i].result_def >= 0) { - tmp = (MAY_BE_RC1 | t1) & ~(MAY_BE_UNDEF|MAY_BE_REF|MAY_BE_RCN); + tmp = (MAY_BE_RC1 | t1) & ~(MAY_BE_UNDEF|MAY_BE_ERROR|MAY_BE_REF|MAY_BE_RCN); if (t1 & MAY_BE_UNDEF) { tmp |= MAY_BE_NULL; } @@ -3076,7 +3076,7 @@ static void zend_update_type_info(const zend_op_array *op_array, } } if (ssa_ops[i].result_def >= 0) { - UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def); + UPDATE_SSA_TYPE(tmp & ~MAY_BE_REF, ssa_ops[i].result_def); if ((t2 & MAY_BE_OBJECT) && ssa_ops[i].op2_use >= 0 && ssa_var_info[ssa_ops[i].op2_use].ce) { UPDATE_SSA_OBJ_TYPE(ssa_var_info[ssa_ops[i].op2_use].ce, ssa_var_info[ssa_ops[i].op2_use].is_instanceof, ssa_ops[i].result_def); } else { @@ -3096,7 +3096,7 @@ static void zend_update_type_info(const zend_op_array *op_array, if (opline->op2_type == IS_VAR && opline->extended_value == ZEND_RETURNS_FUNCTION) { tmp = (MAY_BE_REF | MAY_BE_RCN | MAY_BE_RC1 | t2) & ~MAY_BE_UNDEF; } else { - tmp = (MAY_BE_REF | t2) & ~(MAY_BE_UNDEF | MAY_BE_RC1 | MAY_BE_RCN); + tmp = (MAY_BE_REF | t2) & ~(MAY_BE_UNDEF|MAY_BE_ERROR|MAY_BE_RC1|MAY_BE_RCN); } if (t2 & MAY_BE_UNDEF) { tmp |= MAY_BE_NULL; @@ -3164,6 +3164,16 @@ static void zend_update_type_info(const zend_op_array *op_array, UPDATE_SSA_TYPE(tmp, ssa_ops[i].op1_def); } break; + case ZEND_SEND_UNPACK: + if (ssa_ops[i].op1_def >= 0) { + tmp = t1 | MAY_BE_RC1|MAY_BE_RCN; + if (t1 & MAY_BE_ARRAY) { + /* SEND_UNPACK may acquire references into the array */ + tmp |= MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF; + } + UPDATE_SSA_TYPE(tmp, ssa_ops[i].op1_def); + } + break; case ZEND_FAST_CONCAT: case ZEND_ROPE_INIT: case ZEND_ROPE_ADD: @@ -3605,7 +3615,10 @@ static void zend_update_type_info(const zend_op_array *op_array, } } if (ssa_ops[i].result_def >= 0) { - tmp = MAY_BE_ANY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ERROR; + tmp = MAY_BE_ANY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF; + if (opline->opcode != ZEND_FETCH_OBJ_R && opline->opcode != ZEND_FETCH_OBJ_IS) { + tmp |= MAY_BE_ERROR; + } if (opline->result_type == IS_TMP_VAR) { tmp |= MAY_BE_RC1; } else { @@ -4139,6 +4152,19 @@ static int zend_infer_types(const zend_op_array *op_array, const zend_script *sc /* Narrowing integer initialization to doubles */ zend_type_narrowing(op_array, script, ssa); + for (j = 0; j < op_array->last_var; j++) { + if (zend_string_equals_literal(op_array->vars[j], "php_errormsg")) { + /* Mark all SSA vars for $php_errormsg as references, + * to make sure we don't optimize it. */ + int i; + for (i = 0; i < ssa_vars_count; i++) { + if (ssa->vars[i].var == j) { + ssa_var_info[i].type |= MAY_BE_REF | MAY_BE_ANY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF; + } + } + } + } + if (ZEND_FUNC_INFO(op_array)) { zend_func_return_info(op_array, script, 1, 0, &ZEND_FUNC_INFO(op_array)->return_info); } diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c index a18f79a843..1e4e092512 100644 --- a/ext/opcache/Optimizer/zend_optimizer.c +++ b/ext/opcache/Optimizer/zend_optimizer.c @@ -527,6 +527,70 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array, return 1; } +zend_function *zend_optimizer_get_called_func( + zend_script *script, zend_op_array *op_array, zend_op *opline, zend_bool rt_constants) +{ +#define GET_OP(op) CRT_CONSTANT_EX(op_array, opline->op, rt_constants) + switch (opline->opcode) { + case ZEND_INIT_FCALL: + { + zend_string *function_name = Z_STR_P(GET_OP(op2)); + zend_function *func; + if ((func = zend_hash_find_ptr(&script->function_table, function_name)) != NULL) { + return func; + } else if ((func = zend_hash_find_ptr(EG(function_table), function_name)) != NULL) { + ZEND_ASSERT(func->type == ZEND_INTERNAL_FUNCTION); + return func; + } + break; + } + case ZEND_INIT_FCALL_BY_NAME: + case ZEND_INIT_NS_FCALL_BY_NAME: + if (opline->op2_type == IS_CONST && Z_TYPE_P(GET_OP(op2)) == IS_STRING) { + zval *function_name = GET_OP(op2) + 1; + return zend_hash_find_ptr(&script->function_table, Z_STR_P(function_name)); + } + break; + case ZEND_INIT_STATIC_METHOD_CALL: + if (opline->op2_type == IS_CONST && Z_TYPE_P(GET_OP(op2)) == IS_STRING) { + zend_class_entry *ce = NULL; + if (opline->op1_type == IS_CONST && Z_TYPE_P(GET_OP(op1)) == IS_STRING) { + zend_string *class_name = Z_STR_P(GET_OP(op1) + 1); + ce = zend_hash_find_ptr(&script->class_table, class_name); + } else if (opline->op1_type == IS_UNUSED && op_array->scope + && !(op_array->scope->ce_flags & ZEND_ACC_TRAIT) + && (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) { + ce = op_array->scope; + } + if (ce) { + zend_string *func_name = Z_STR_P(GET_OP(op2) + 1); + return zend_hash_find_ptr(&ce->function_table, func_name); + } + } + break; + case ZEND_INIT_METHOD_CALL: + if (opline->op1_type == IS_UNUSED + && opline->op2_type == IS_CONST && Z_TYPE_P(GET_OP(op2)) == IS_STRING + && op_array->scope && !(op_array->scope->ce_flags & ZEND_ACC_TRAIT)) { + zend_string *method_name = Z_STR_P(GET_OP(op2) + 1); + zend_function *fbc = zend_hash_find_ptr( + &op_array->scope->function_table, method_name); + if (fbc) { + zend_bool is_private = (fbc->common.fn_flags & ZEND_ACC_PRIVATE) != 0; + zend_bool is_final = (fbc->common.fn_flags & ZEND_ACC_FINAL) != 0; + zend_bool same_scope = fbc->common.scope == op_array->scope; + if ((is_private && same_scope) + || (is_final && (!is_private || same_scope))) { + return fbc; + } + } + } + break; + } + return NULL; +#undef GET_OP +} + static void zend_optimize(zend_op_array *op_array, zend_optimizer_ctx *ctx) { @@ -751,8 +815,7 @@ static void zend_adjust_fcall_stack_size_graph(zend_op_array *op_array) while (call_info) { zend_op *opline = call_info->caller_init_opline; - if (opline && call_info->callee_func) { - ZEND_ASSERT(opline->opcode == ZEND_INIT_FCALL); + if (opline && call_info->callee_func && opline->opcode == ZEND_INIT_FCALL) { opline->op1.num = zend_vm_calc_used_stack(opline->extended_value, call_info->callee_func); } call_info = call_info->next_callee; diff --git a/ext/opcache/Optimizer/zend_optimizer_internal.h b/ext/opcache/Optimizer/zend_optimizer_internal.h index 220a00d6c4..1d51b57634 100644 --- a/ext/opcache/Optimizer/zend_optimizer_internal.h +++ b/ext/opcache/Optimizer/zend_optimizer_internal.h @@ -106,5 +106,7 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c void zend_optimizer_nop_removal(zend_op_array *op_array); void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx *ctx); int zend_optimizer_is_disabled_func(const char *name, size_t len); +zend_function *zend_optimizer_get_called_func( + zend_script *script, zend_op_array *op_array, zend_op *opline, zend_bool rt_constants); #endif diff --git a/ext/opcache/Optimizer/zend_ssa.c b/ext/opcache/Optimizer/zend_ssa.c index a55ccc915a..201317f207 100644 --- a/ext/opcache/Optimizer/zend_ssa.c +++ b/ext/opcache/Optimizer/zend_ssa.c @@ -23,19 +23,47 @@ #include "zend_dump.h" #include "zend_inference.h" -static int needs_pi(const zend_op_array *op_array, zend_dfg *dfg, zend_ssa *ssa, int from, int to, int var) /* {{{ */ -{ - if (from == to || ssa->cfg.blocks[to].predecessors_count != 1) { - zend_ssa_phi *p = ssa->blocks[to].phis; - while (p) { - if (p->pi < 0 && p->var == var) { - return 1; - } - p = p->next; +static zend_bool dominates(const zend_basic_block *blocks, int a, int b) { + while (blocks[b].level > blocks[a].level) { + b = blocks[b].idom; + } + return a == b; +} + +static zend_bool dominates_other_predecessors( + const zend_cfg *cfg, const zend_basic_block *block, int check, int exclude) { + int i; + for (i = 0; i < block->predecessors_count; i++) { + int predecessor = cfg->predecessors[block->predecessor_offset + i]; + if (predecessor != exclude && !dominates(cfg->blocks, check, predecessor)) { + return 0; } + } + return 1; +} + +static zend_bool needs_pi(const zend_op_array *op_array, zend_dfg *dfg, zend_ssa *ssa, int from, int to, int var) /* {{{ */ +{ + zend_basic_block *from_block, *to_block; + int other_successor; + + if (!DFG_ISSET(dfg->in, dfg->size, to, var)) { + /* Variable is not live, certainly won't benefit from pi */ return 0; } - return DFG_ISSET(dfg->in, dfg->size, to, var); + + to_block = &ssa->cfg.blocks[to]; + if (to_block->predecessors_count == 1) { + /* Always place pi if one predecessor (an if branch) */ + return 1; + } + + /* Check that the other successor of the from block does not dominate all other predecessors. + * If it does, we'd probably end up annihilating a positive+negative pi assertion. */ + from_block = &ssa->cfg.blocks[from]; + other_successor = from_block->successors[0] == to + ? from_block->successors[1] : from_block->successors[0]; + return !dominates_other_predecessors(&ssa->cfg, to_block, other_successor, from); } /* }}} */ @@ -62,6 +90,11 @@ static zend_ssa_phi *add_pi( phi->next = ssa->blocks[to].phis; ssa->blocks[to].phis = phi; + /* Block "to" now defines "var" via the pi statement, so add it to the "def" set. Note that + * this is not entirely accurate, because the pi is actually placed along the edge from->to. + * If there is a back-edge to "to" this may result in non-minimal SSA form. */ + DFG_SET(dfg->def, dfg->size, to, var); + return phi; } /* }}} */ @@ -585,6 +618,7 @@ static int zend_ssa_rename(const zend_op_array *op_array, uint32_t build_flags, case ZEND_SEND_VAR_NO_REF: case ZEND_SEND_VAR_EX: case ZEND_SEND_REF: + case ZEND_SEND_UNPACK: case ZEND_FE_RESET_RW: //TODO: ??? if (opline->op1_type == IS_CV) { @@ -764,7 +798,7 @@ int zend_build_ssa(zend_arena **arena, const zend_op_array *op_array, uint32_t b zend_ssa_block *ssa_blocks; int blocks_count = ssa->cfg.blocks_count; uint32_t set_size; - zend_bitset tmp, gen, in; + zend_bitset tmp, def, in; int *var = NULL; int i, j, k, changed; zend_dfg dfg; @@ -781,10 +815,9 @@ int zend_build_ssa(zend_arena **arena, const zend_op_array *op_array, uint32_t b /* Compute Variable Liveness */ dfg.vars = op_array->last_var + op_array->T; dfg.size = set_size = zend_bitset_len(dfg.vars); - dfg.tmp = do_alloca((set_size * sizeof(zend_ulong)) * (blocks_count * 5 + 1), dfg_use_heap); - memset(dfg.tmp, 0, (set_size * sizeof(zend_ulong)) * (blocks_count * 5 + 1)); - dfg.gen = dfg.tmp + set_size; - dfg.def = dfg.gen + set_size * blocks_count; + dfg.tmp = do_alloca((set_size * sizeof(zend_ulong)) * (blocks_count * 4 + 1), dfg_use_heap); + memset(dfg.tmp, 0, (set_size * sizeof(zend_ulong)) * (blocks_count * 4 + 1)); + dfg.def = dfg.tmp + set_size; dfg.use = dfg.def + set_size * blocks_count; dfg.in = dfg.use + set_size * blocks_count; dfg.out = dfg.in + set_size * blocks_count; @@ -799,27 +832,31 @@ int zend_build_ssa(zend_arena **arena, const zend_op_array *op_array, uint32_t b } tmp = dfg.tmp; - gen = dfg.gen; + def = dfg.def; in = dfg.in; - /* SSA construction, Step 1: Propagate "gen" sets in merge points */ + /* Place e-SSA pis. This will add additional "def" points, so it must + * happen before def propagation. */ + place_essa_pis(arena, op_array, build_flags, ssa, &dfg); + + /* SSA construction, Step 1: Propagate "def" sets in merge points */ do { changed = 0; for (j = 0; j < blocks_count; j++) { if ((blocks[j].flags & ZEND_BB_REACHABLE) == 0) { continue; } - if (j >= 0 && (blocks[j].predecessors_count > 1 || j == 0)) { - zend_bitset_copy(tmp, gen + (j * set_size), set_size); + if (blocks[j].predecessors_count > 1 || j == 0) { + zend_bitset_copy(tmp, def + (j * set_size), set_size); for (k = 0; k < blocks[j].predecessors_count; k++) { i = ssa->cfg.predecessors[blocks[j].predecessor_offset + k]; while (i != -1 && i != blocks[j].idom) { - zend_bitset_union_with_intersection(tmp, tmp, gen + (i * set_size), in + (j * set_size), set_size); + zend_bitset_union_with_intersection(tmp, tmp, def + (i * set_size), in + (j * set_size), set_size); i = blocks[i].idom; } } - if (!zend_bitset_equal(gen + (j * set_size), tmp, set_size)) { - zend_bitset_copy(gen + (j * set_size), tmp, set_size); + if (!zend_bitset_equal(def + (j * set_size), tmp, set_size)) { + zend_bitset_copy(def + (j * set_size), tmp, set_size); changed = 1; } } @@ -849,110 +886,40 @@ int zend_build_ssa(zend_arena **arena, const zend_op_array *op_array, uint32_t b for (k = 0; k < blocks[j].predecessors_count; k++) { i = ssa->cfg.predecessors[blocks[j].predecessor_offset + k]; while (i != -1 && i != blocks[j].idom) { - zend_bitset_union_with_intersection(tmp, tmp, gen + (i * set_size), in + (j * set_size), set_size); + zend_bitset_union_with_intersection(tmp, tmp, def + (i * set_size), in + (j * set_size), set_size); i = blocks[i].idom; } } } if (!zend_bitset_empty(tmp, set_size)) { - i = op_array->last_var + op_array->T; - while (i > 0) { - i--; - if (zend_bitset_in(tmp, i)) { - zend_ssa_phi *phi = zend_arena_calloc(arena, 1, - sizeof(zend_ssa_phi) + - sizeof(int) * blocks[j].predecessors_count + - sizeof(void*) * blocks[j].predecessors_count); - - if (!phi) { - goto failure; - } - phi->sources = (int*)(((char*)phi) + sizeof(zend_ssa_phi)); - memset(phi->sources, 0xff, sizeof(int) * blocks[j].predecessors_count); - phi->use_chains = (zend_ssa_phi**)(((char*)phi->sources) + sizeof(int) * ssa->cfg.blocks[j].predecessors_count); - - phi->pi = -1; - phi->var = i; - phi->ssa_var = -1; - phi->next = ssa_blocks[j].phis; - ssa_blocks[j].phis = phi; - } - } - } - } - } + ZEND_BITSET_REVERSE_FOREACH(tmp, set_size, i) { + zend_ssa_phi *phi = zend_arena_calloc(arena, 1, + sizeof(zend_ssa_phi) + + sizeof(int) * blocks[j].predecessors_count + + sizeof(void*) * blocks[j].predecessors_count); - place_essa_pis(arena, op_array, build_flags, ssa, &dfg); + phi->sources = (int*)(((char*)phi) + sizeof(zend_ssa_phi)); + memset(phi->sources, 0xff, sizeof(int) * blocks[j].predecessors_count); + phi->use_chains = (zend_ssa_phi**)(((char*)phi->sources) + sizeof(int) * ssa->cfg.blocks[j].predecessors_count); - /* SSA construction, Step ?: Phi after Pi placement based on Dominance Frontiers */ - for (j = 0; j < blocks_count; j++) { - if ((blocks[j].flags & ZEND_BB_REACHABLE) == 0) { - continue; - } - if (blocks[j].predecessors_count > 1) { - zend_bitset_clear(tmp, set_size); - if (blocks[j].flags & ZEND_BB_IRREDUCIBLE_LOOP) { - /* Prevent any values from flowing into irreducible loops by - replacing all incoming values with explicit phis. The - register allocator depends on this property. */ - zend_bitset_copy(tmp, in + (j * set_size), set_size); - } else { - for (k = 0; k < blocks[j].predecessors_count; k++) { - i = ssa->cfg.predecessors[blocks[j].predecessor_offset + k]; - while (i != -1 && i != blocks[j].idom) { - zend_ssa_phi *p = ssa_blocks[i].phis; - while (p) { - if (p) { - if (p->pi >= 0) { - if (zend_bitset_in(in + (j * set_size), p->var) && - !zend_bitset_in(gen + (i * set_size), p->var)) { - zend_bitset_incl(tmp, p->var); - } - } else { - zend_bitset_excl(tmp, p->var); - } - } - p = p->next; - } - i = blocks[i].idom; - } - } - } + phi->pi = -1; + phi->var = i; + phi->ssa_var = -1; - if (!zend_bitset_empty(tmp, set_size)) { - i = op_array->last_var + op_array->T; - while (i > 0) { - i--; - if (zend_bitset_in(tmp, i)) { + /* Place phis after pis */ + { zend_ssa_phi **pp = &ssa_blocks[j].phis; while (*pp) { - if ((*pp)->pi <= 0 && (*pp)->var == i) { + if ((*pp)->pi < 0) { break; } pp = &(*pp)->next; } - if (*pp == NULL) { - zend_ssa_phi *phi = zend_arena_calloc(arena, 1, - sizeof(zend_ssa_phi) + - sizeof(int) * blocks[j].predecessors_count + - sizeof(void*) * blocks[j].predecessors_count); - - if (!phi) { - goto failure; - } - phi->sources = (int*)(((char*)phi) + sizeof(zend_ssa_phi)); - memset(phi->sources, 0xff, sizeof(int) * blocks[j].predecessors_count); - phi->use_chains = (zend_ssa_phi**)(((char*)phi->sources) + sizeof(int) * ssa->cfg.blocks[j].predecessors_count); - - phi->pi = -1; - phi->var = i; - phi->ssa_var = -1; - phi->next = NULL; - *pp = phi; - } + phi->next = *pp; + *pp = phi; } - } + } ZEND_BITSET_FOREACH_END(); } } } @@ -971,7 +938,6 @@ int zend_build_ssa(zend_arena **arena, const zend_op_array *op_array, uint32_t b } ssa->vars_count = op_array->last_var; if (zend_ssa_rename(op_array, build_flags, ssa, var, 0) != SUCCESS) { -failure: free_alloca(var, var_use_heap); free_alloca(dfg.tmp, dfg_use_heap); return FAILURE; diff --git a/ext/opcache/README b/ext/opcache/README index 11c9c2748b..e4d36ba51a 100644 --- a/ext/opcache/README +++ b/ext/opcache/README @@ -215,4 +215,4 @@ opcache.mmap_base errors. opcache.lockfile_path (default "/tmp") - Absolute path used to store shared lockfiles. + Absolute path used to store shared lockfiles (for *nix only) diff --git a/ext/opcache/ZendAccelerator.h b/ext/opcache/ZendAccelerator.h index b4119bcd45..ffcb1b6eb6 100644 --- a/ext/opcache/ZendAccelerator.h +++ b/ext/opcache/ZendAccelerator.h @@ -195,7 +195,9 @@ typedef struct _zend_accel_directives { zend_long max_file_size; zend_long interned_strings_buffer; char *restrict_api; +#ifndef ZEND_WIN32 char *lockfile_path; +#endif #ifdef HAVE_OPCACHE_FILE_CACHE char *file_cache; zend_bool file_cache_only; diff --git a/ext/opcache/tests/bug72014.phpt b/ext/opcache/tests/bug72014.phpt new file mode 100644 index 0000000000..d2ad96c0f1 --- /dev/null +++ b/ext/opcache/tests/bug72014.phpt @@ -0,0 +1,29 @@ +--TEST-- +Bug #72014 (Including a file with anonymous classes multiple times leads to fatal error) +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.file_update_protection=0 +--SKIPIF-- +<?php require_once('skipif.inc'); ?> +--FILE-- +<?php +file_put_contents(__DIR__ . "/bug72014.annon.php", <<<PHP +<?php +\$a = new class() { public \$testvar = "Foo\n"; }; +echo \$a->testvar; +PHP +); + +include(__DIR__ . "/bug72014.annon.php"); +include(__DIR__ . "/bug72014.annon.php"); +include(__DIR__ . "/bug72014.annon.php"); +?> +--CLEAN-- +<?php +@unlink(__DIR__ . "/bug72014.annon.php") +?> +--EXPECT-- +Foo +Foo +Foo diff --git a/ext/opcache/zend_accelerator_module.c b/ext/opcache/zend_accelerator_module.c index 92f496c359..aa01073c97 100644 --- a/ext/opcache/zend_accelerator_module.c +++ b/ext/opcache/zend_accelerator_module.c @@ -299,9 +299,10 @@ ZEND_INI_BEGIN() STD_PHP_INI_BOOLEAN("opcache.enable_cli" , "0" , PHP_INI_SYSTEM, OnUpdateBool, accel_directives.enable_cli, zend_accel_globals, accel_globals) STD_PHP_INI_ENTRY("opcache.error_log" , "" , PHP_INI_SYSTEM, OnUpdateString, accel_directives.error_log, zend_accel_globals, accel_globals) STD_PHP_INI_ENTRY("opcache.restrict_api" , "" , PHP_INI_SYSTEM, OnUpdateString, accel_directives.restrict_api, zend_accel_globals, accel_globals) - STD_PHP_INI_ENTRY("opcache.lockfile_path" , "/tmp" , PHP_INI_SYSTEM, OnUpdateString, accel_directives.lockfile_path, zend_accel_globals, accel_globals) -#ifdef ZEND_WIN32 +#ifndef ZEND_WIN32 + STD_PHP_INI_ENTRY("opcache.lockfile_path" , "/tmp" , PHP_INI_SYSTEM, OnUpdateString, accel_directives.lockfile_path, zend_accel_globals, accel_globals) +#else STD_PHP_INI_ENTRY("opcache.mmap_base", NULL, PHP_INI_SYSTEM, OnUpdateString, accel_directives.mmap_base, zend_accel_globals, accel_globals) #endif @@ -712,7 +713,10 @@ static ZEND_FUNCTION(opcache_get_configuration) add_assoc_bool(&directives, "opcache.fast_shutdown", ZCG(accel_directives).fast_shutdown); add_assoc_bool(&directives, "opcache.enable_file_override", ZCG(accel_directives).file_override_enabled); add_assoc_long(&directives, "opcache.optimization_level", ZCG(accel_directives).optimization_level); + +#ifndef ZEND_WIN32 add_assoc_string(&directives, "opcache.lockfile_path", STRING_NOT_NULL(ZCG(accel_directives).lockfile_path)); +#endif #ifdef HAVE_OPCACHE_FILE_CACHE add_assoc_string(&directives, "opcache.file_cache", ZCG(accel_directives).file_cache ? ZCG(accel_directives).file_cache : ""); diff --git a/ext/opcache/zend_accelerator_util_funcs.c b/ext/opcache/zend_accelerator_util_funcs.c index 27731dd624..61c9c15d2b 100644 --- a/ext/opcache/zend_accelerator_util_funcs.c +++ b/ext/opcache/zend_accelerator_util_funcs.c @@ -40,8 +40,6 @@ typedef int (*id_function_t)(void *, void *); typedef void (*unique_copy_ctor_func_t)(void *pElement); -static zend_ast *zend_ast_clone(zend_ast *ast); - static void zend_accel_destroy_zend_function(zval *zv) { zend_function *function = Z_PTR_P(zv); @@ -169,61 +167,6 @@ static inline void zend_clone_zval(zval *src) src = Z_REFVAL_P(src); } } - if (Z_TYPE_P(src) == IS_CONSTANT_AST) { - if (Z_REFCOUNT_P(src) > 1 && (ptr = accel_xlat_get(Z_AST_P(src))) != NULL) { - Z_AST_P(src) = ptr; - } else { - zend_ast_ref *old = Z_AST_P(src); - - ZVAL_NEW_AST(src, old->ast); - Z_AST_P(src)->gc = old->gc; - if (Z_REFCOUNT_P(src) > 1) { - accel_xlat_set(old, Z_AST_P(src)); - } - Z_ASTVAL_P(src) = zend_ast_clone(Z_ASTVAL_P(src)); - } - } -} - -static zend_ast *zend_ast_clone(zend_ast *ast) -{ - uint32_t i; - - if (ast->kind == ZEND_AST_ZVAL) { - zend_ast_zval *copy = emalloc(sizeof(zend_ast_zval)); - copy->kind = ZEND_AST_ZVAL; - copy->attr = ast->attr; - ZVAL_COPY_VALUE(©->val, zend_ast_get_zval(ast)); - return (zend_ast *) copy; - } else if (zend_ast_is_list(ast)) { - zend_ast_list *list = zend_ast_get_list(ast); - zend_ast_list *copy = emalloc( - sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * list->children); - copy->kind = list->kind; - copy->attr = list->attr; - copy->children = list->children; - for (i = 0; i < list->children; i++) { - if (list->child[i]) { - copy->child[i] = zend_ast_clone(list->child[i]); - } else { - copy->child[i] = NULL; - } - } - return (zend_ast *) copy; - } else { - uint32_t children = zend_ast_get_num_children(ast); - zend_ast *copy = emalloc(sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children); - copy->kind = ast->kind; - copy->attr = ast->attr; - for (i = 0; i < children; i++) { - if (ast->child[i]) { - copy->child[i] = zend_ast_clone(ast->child[i]); - } else { - copy->child[i] = NULL; - } - } - return copy; - } } static void zend_hash_clone_constants(HashTable *ht, HashTable *source) @@ -617,7 +560,6 @@ failure: static void zend_accel_class_hash_copy(HashTable *target, HashTable *source, unique_copy_ctor_func_t pCopyConstructor) { - zend_class_entry *ce1; Bucket *p, *end; zval *t; @@ -633,7 +575,17 @@ static void zend_accel_class_hash_copy(HashTable *target, HashTable *source, uni /* Mangled key - ignore and wait for runtime */ continue; } else if (UNEXPECTED(!ZCG(accel_directives).ignore_dups)) { - goto failure; + zend_class_entry *ce1 = Z_PTR(p->val); + if (!(ce1->ce_flags & ZEND_ACC_ANON_CLASS)) { + CG(in_compilation) = 1; + zend_set_compiled_filename(ce1->info.user.filename); + CG(zend_lineno) = ce1->info.user.line_start; + zend_error(E_ERROR, + "Cannot declare %s %s, because the name is already in use", + zend_get_object_type(ce1), ZSTR_VAL(ce1->name)); + return; + } + continue; } } else { t = _zend_hash_append_ptr(target, p->key, Z_PTR(p->val)); @@ -644,13 +596,6 @@ static void zend_accel_class_hash_copy(HashTable *target, HashTable *source, uni } target->nInternalPointer = target->nNumOfElements ? 0 : HT_INVALID_IDX; return; - -failure: - ce1 = Z_PTR(p->val); - CG(in_compilation) = 1; - zend_set_compiled_filename(ce1->info.user.filename); - CG(zend_lineno) = ce1->info.user.line_start; - zend_error(E_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce1), ZSTR_VAL(ce1->name)); } #ifdef __SSE2__ diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index aa3b8e82f3..25a504575d 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -65,7 +65,6 @@ typedef void (*zend_persist_func_t)(zval*); static void zend_persist_zval(zval *z); -static void zend_persist_zval_const(zval *z); static const uint32_t uninitialized_bucket[-HT_MIN_MASK] = {HT_INVALID_IDX, HT_INVALID_IDX}; @@ -204,7 +203,7 @@ static void zend_hash_persist_immutable(HashTable *ht) } /* persist the data itself */ - zend_persist_zval_const(&p->val); + zend_persist_zval(&p->val); nIndex = p->h | ht->nTableMask; Z_NEXT(p->val) = HT_HASH(ht, nIndex); @@ -229,7 +228,7 @@ static void zend_hash_persist_immutable(HashTable *ht) } /* persist the data itself */ - zend_persist_zval_const(&p->val); + zend_persist_zval(&p->val); } } @@ -278,63 +277,10 @@ static void zend_persist_zval(zval *z) zend_accel_store_interned_string(Z_STR_P(z)); Z_GC_FLAGS_P(z) |= flags; Z_TYPE_FLAGS_P(z) &= ~(IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); - break; - case IS_ARRAY: - new_ptr = zend_shared_alloc_get_xlat_entry(Z_ARR_P(z)); - if (new_ptr) { - Z_ARR_P(z) = new_ptr; - Z_TYPE_FLAGS_P(z) = IS_TYPE_IMMUTABLE; - } else { - if (Z_IMMUTABLE_P(z)) { - Z_ARR_P(z) = zend_accel_memdup(Z_ARR_P(z), sizeof(zend_array)); - zend_hash_persist_immutable(Z_ARRVAL_P(z)); - } else { - GC_REMOVE_FROM_BUFFER(Z_ARR_P(z)); - zend_accel_store(Z_ARR_P(z), sizeof(zend_array)); - zend_hash_persist(Z_ARRVAL_P(z), zend_persist_zval); - /* make immutable array */ - Z_TYPE_FLAGS_P(z) = IS_TYPE_IMMUTABLE; - GC_REFCOUNT(Z_COUNTED_P(z)) = 2; - GC_FLAGS(Z_COUNTED_P(z)) |= IS_ARRAY_IMMUTABLE; - Z_ARRVAL_P(z)->u.flags |= HASH_FLAG_STATIC_KEYS; - Z_ARRVAL_P(z)->u.flags &= ~HASH_FLAG_APPLY_PROTECTION; - } - } - break; - case IS_REFERENCE: - new_ptr = zend_shared_alloc_get_xlat_entry(Z_REF_P(z)); - if (new_ptr) { - Z_REF_P(z) = new_ptr; - } else { - zend_accel_store(Z_REF_P(z), sizeof(zend_reference)); - zend_persist_zval(Z_REFVAL_P(z)); - } - break; - case IS_CONSTANT_AST: - new_ptr = zend_shared_alloc_get_xlat_entry(Z_AST_P(z)); - if (new_ptr) { - Z_AST_P(z) = new_ptr; - } else { - zend_accel_store(Z_AST_P(z), sizeof(zend_ast_ref)); - Z_ASTVAL_P(z) = zend_persist_ast(Z_ASTVAL_P(z)); + if (Z_TYPE_P(z) == IS_CONSTANT) { + Z_TYPE_FLAGS_P(z) |= IS_TYPE_IMMUTABLE; } break; - } -} - -static void zend_persist_zval_static(zval *z) -{ - zend_uchar flags; - void *new_ptr; - - switch (Z_TYPE_P(z)) { - case IS_STRING: - case IS_CONSTANT: - flags = Z_GC_FLAGS_P(z) & ~ (IS_STR_PERSISTENT | IS_STR_INTERNED | IS_STR_PERMANENT); - zend_accel_store_interned_string(Z_STR_P(z)); - Z_GC_FLAGS_P(z) |= flags; - Z_TYPE_FLAGS_P(z) &= ~(IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); - break; case IS_ARRAY: new_ptr = zend_shared_alloc_get_xlat_entry(Z_ARR_P(z)); if (new_ptr) { @@ -381,62 +327,6 @@ static void zend_persist_zval_static(zval *z) } } -static void zend_persist_zval_const(zval *z) -{ - zend_uchar flags; - void *new_ptr; - - switch (Z_TYPE_P(z)) { - case IS_STRING: - case IS_CONSTANT: - flags = Z_GC_FLAGS_P(z) & ~ (IS_STR_PERSISTENT | IS_STR_INTERNED | IS_STR_PERMANENT); - zend_accel_memdup_interned_string(Z_STR_P(z)); - Z_GC_FLAGS_P(z) |= flags; - Z_TYPE_FLAGS_P(z) &= ~(IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); - break; - case IS_ARRAY: - new_ptr = zend_shared_alloc_get_xlat_entry(Z_ARR_P(z)); - if (new_ptr) { - Z_ARR_P(z) = new_ptr; - Z_TYPE_FLAGS_P(z) = IS_TYPE_IMMUTABLE; - } else { - if (Z_IMMUTABLE_P(z)) { - Z_ARR_P(z) = zend_accel_memdup(Z_ARR_P(z), sizeof(zend_array)); - zend_hash_persist_immutable(Z_ARRVAL_P(z)); - } else { - GC_REMOVE_FROM_BUFFER(Z_ARR_P(z)); - zend_accel_store(Z_ARR_P(z), sizeof(zend_array)); - zend_hash_persist(Z_ARRVAL_P(z), zend_persist_zval); - /* make immutable array */ - Z_TYPE_FLAGS_P(z) = IS_TYPE_IMMUTABLE; - GC_REFCOUNT(Z_COUNTED_P(z)) = 2; - GC_FLAGS(Z_COUNTED_P(z)) |= IS_ARRAY_IMMUTABLE; - Z_ARRVAL_P(z)->u.flags |= HASH_FLAG_STATIC_KEYS; - Z_ARRVAL_P(z)->u.flags &= ~HASH_FLAG_APPLY_PROTECTION; - } - } - break; - case IS_REFERENCE: - new_ptr = zend_shared_alloc_get_xlat_entry(Z_REF_P(z)); - if (new_ptr) { - Z_REF_P(z) = new_ptr; - } else { - zend_accel_store(Z_REF_P(z), sizeof(zend_reference)); - zend_persist_zval(Z_REFVAL_P(z)); - } - break; - case IS_CONSTANT_AST: - new_ptr = zend_shared_alloc_get_xlat_entry(Z_AST_P(z)); - if (new_ptr) { - Z_AST_P(z) = new_ptr; - } else { - zend_accel_store(Z_AST_P(z), sizeof(zend_ast_ref)); - Z_ASTVAL_P(z) = zend_persist_ast(Z_ASTVAL_P(z)); - } - break; - } -} - static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_script* main_persistent_script) { int already_stored = 0; @@ -472,7 +362,7 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc if (stored) { op_array->static_variables = stored; } else { - zend_hash_persist(op_array->static_variables, zend_persist_zval_static); + zend_hash_persist(op_array->static_variables, zend_persist_zval); zend_accel_store(op_array->static_variables, sizeof(HashTable)); /* make immutable array */ GC_REFCOUNT(op_array->static_variables) = 2; diff --git a/ext/openssl/xp_ssl.c b/ext/openssl/xp_ssl.c index 53536a1a77..6f542323d2 100644 --- a/ext/openssl/xp_ssl.c +++ b/ext/openssl/xp_ssl.c @@ -2199,39 +2199,39 @@ static inline int php_openssl_tcp_sockop_accept(php_stream *stream, php_openssl_ php_stream_xport_param *xparam STREAMS_DC) { int clisock; - + zend_bool nodelay = 0; + zval *tmpzval = NULL; + xparam->outputs.client = NULL; + if ((tmpzval = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), "socket", "tcp_nodelay")) != NULL && + zend_is_true(tmpzval)) { + nodelay = 1; + } + clisock = php_network_accept_incoming(sock->s.socket, - xparam->want_textaddr ? &xparam->outputs.textaddr : NULL, - xparam->want_addr ? &xparam->outputs.addr : NULL, - xparam->want_addr ? &xparam->outputs.addrlen : NULL, - xparam->inputs.timeout, - xparam->want_errortext ? &xparam->outputs.error_text : NULL, - &xparam->outputs.error_code - ); + xparam->want_textaddr ? &xparam->outputs.textaddr : NULL, + xparam->want_addr ? &xparam->outputs.addr : NULL, + xparam->want_addr ? &xparam->outputs.addrlen : NULL, + xparam->inputs.timeout, + xparam->want_errortext ? &xparam->outputs.error_text : NULL, + &xparam->outputs.error_code, + nodelay); if (clisock >= 0) { - php_openssl_netstream_data_t *clisockdata; + php_openssl_netstream_data_t *clisockdata = (php_openssl_netstream_data_t*) emalloc(sizeof(*clisockdata)); - clisockdata = emalloc(sizeof(*clisockdata)); + /* copy underlying tcp fields */ + memset(clisockdata, 0, sizeof(*clisockdata)); + memcpy(clisockdata, sock, sizeof(clisockdata->s)); - if (clisockdata == NULL) { - closesocket(clisock); - /* technically a fatal error */ - } else { - /* copy underlying tcp fields */ - memset(clisockdata, 0, sizeof(*clisockdata)); - memcpy(clisockdata, sock, sizeof(clisockdata->s)); - - clisockdata->s.socket = clisock; + clisockdata->s.socket = clisock; - xparam->outputs.client = php_stream_alloc_rel(stream->ops, clisockdata, NULL, "r+"); - if (xparam->outputs.client) { - xparam->outputs.client->ctx = stream->ctx; - if (stream->ctx) { - GC_REFCOUNT(stream->ctx)++; - } + xparam->outputs.client = php_stream_alloc_rel(stream->ops, clisockdata, NULL, "r+"); + if (xparam->outputs.client) { + xparam->outputs.client->ctx = stream->ctx; + if (stream->ctx) { + GC_REFCOUNT(stream->ctx)++; } } diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c index f6f86304e5..35ba1a06f1 100644 --- a/ext/pcre/php_pcre.c +++ b/ext/pcre/php_pcre.c @@ -1030,7 +1030,7 @@ static int preg_get_backref(char **str, int *backref) } if (in_brace) { - if (*walk == 0 || *walk != '}') + if (*walk != '}') return 0; else walk++; diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c index 1d77f3e0eb..624281c18b 100644 --- a/ext/pdo/pdo_dbh.c +++ b/ext/pdo/pdo_dbh.c @@ -436,7 +436,6 @@ static void pdo_stmt_construct(zend_execute_data *execute_data, pdo_stmt_t *stmt zval retval; fci.size = sizeof(zend_fcall_info); - fci.function_table = &dbstmt_ce->function_table; ZVAL_UNDEF(&fci.function_name); fci.object = Z_OBJ_P(object); fci.retval = &retval; @@ -448,7 +447,7 @@ static void pdo_stmt_construct(zend_execute_data *execute_data, pdo_stmt_t *stmt fcc.initialized = 1; fcc.function_handler = dbstmt_ce->constructor; - fcc.calling_scope = EG(scope); + fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = Z_OBJCE_P(object); fcc.object = Z_OBJ_P(object); diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c index da557b8597..c2f3c13399 100644 --- a/ext/pdo/pdo_stmt.c +++ b/ext/pdo/pdo_stmt.c @@ -740,7 +740,6 @@ static int do_fetch_class_prepare(pdo_stmt_t *stmt) /* {{{ */ } if (ce->constructor) { - fci->function_table = &ce->function_table; ZVAL_UNDEF(&fci->function_name); fci->retval = &stmt->fetch.cls.retval; fci->param_count = 0; @@ -751,7 +750,7 @@ static int do_fetch_class_prepare(pdo_stmt_t *stmt) /* {{{ */ fcc->initialized = 1; fcc->function_handler = ce->constructor; - fcc->calling_scope = EG(scope); + fcc->calling_scope = zend_get_executed_scope(); fcc->called_scope = ce; return 1; } else if (!Z_ISUNDEF(stmt->fetch.cls.ctor_args)) { diff --git a/ext/pdo_oci/tests/pdo_oci_stream_2a.phpt b/ext/pdo_oci/tests/pdo_oci_stream_2a.phpt index a7f22d5c41..72d2ed93b1 100644 --- a/ext/pdo_oci/tests/pdo_oci_stream_2a.phpt +++ b/ext/pdo_oci/tests/pdo_oci_stream_2a.phpt @@ -53,16 +53,16 @@ $a10 = str_repeat('j', 4095); printf("Inserting 10000 Records ... "); for($i=0; $i<1000; $i++) { - do_insert($db, 1, $a1, $a10); - do_insert($db, 1, $a2, $a9); - do_insert($db, 1, $a3, $a8); - do_insert($db, 1, $a4, $a7); - do_insert($db, 1, $a5, $a6); - do_insert($db, 1, $a6, $a5); - do_insert($db, 1, $a7, $a4); - do_insert($db, 1, $a8, $a3); - do_insert($db, 1, $a9, $a2); - do_insert($db, 1, $a10, $a1); + do_insert($db, $i * 10 + 1, $a1, $a10); + do_insert($db, $i * 10 + 2, $a2, $a9); + do_insert($db, $i * 10 + 3, $a3, $a8); + do_insert($db, $i * 10 + 4, $a4, $a7); + do_insert($db, $i * 10 + 5, $a5, $a6); + do_insert($db, $i * 10 + 6, $a6, $a5); + do_insert($db, $i * 10 + 7, $a7, $a4); + do_insert($db, $i * 10 + 8, $a8, $a3); + do_insert($db, $i * 10 + 9, $a9, $a2); + do_insert($db, $i * 10 + 10, $a10, $a1); } printf("Done\n"); diff --git a/ext/pdo_sqlite/sqlite_driver.c b/ext/pdo_sqlite/sqlite_driver.c index 8c732b9dbe..4e729aab0e 100644 --- a/ext/pdo_sqlite/sqlite_driver.c +++ b/ext/pdo_sqlite/sqlite_driver.c @@ -325,7 +325,6 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb, fake_argc = argc + is_agg; fc->fci.size = sizeof(fc->fci); - fc->fci.function_table = EG(function_table); ZVAL_COPY_VALUE(&fc->fci.function_name, cb); fc->fci.object = NULL; fc->fci.retval = &retval; @@ -475,7 +474,6 @@ static int php_sqlite3_collation_callback(void *context, struct pdo_sqlite_collation *collation = (struct pdo_sqlite_collation*) context; collation->fc.fci.size = sizeof(collation->fc.fci); - collation->fc.fci.function_table = EG(function_table); ZVAL_COPY_VALUE(&collation->fc.fci.function_name, &collation->callback); collation->fc.fci.object = NULL; collation->fc.fci.retval = &retval; diff --git a/ext/pdo_sqlite/tests/bug70221.phpt b/ext/pdo_sqlite/tests/bug70221.phpt index 1ee2378bc6..2d1aea0e8b 100644 --- a/ext/pdo_sqlite/tests/bug70221.phpt +++ b/ext/pdo_sqlite/tests/bug70221.phpt @@ -6,10 +6,13 @@ if (!extension_loaded('pdo_sqlite')) print 'skip not loaded'; ?> --FILE-- <?php -$db = new PDO('sqlite:test.sqlite', null, null, array(PDO::ATTR_PERSISTENT => true)); +$dbfile = __DIR__ . '/test.sqlite'; +$db = new PDO('sqlite:'.$dbfile, null, null, array(PDO::ATTR_PERSISTENT => true)); function _test() { return 42; } $db->sqliteCreateFunction('test', '_test', 0); print("Everything is fine, no exceptions here\n"); +unset($db); +@unlink($dbfile); ?> --EXPECT-- Everything is fine, no exceptions here diff --git a/ext/pgsql/pgsql.c b/ext/pgsql/pgsql.c index af6db069b6..408802cfbf 100644 --- a/ext/pgsql/pgsql.c +++ b/ext/pgsql/pgsql.c @@ -1974,7 +1974,7 @@ PHP_FUNCTION(pg_query_params) params = (char **)safe_emalloc(sizeof(char *), num_params, 0); ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(pv_param_arr), tmp) { - + ZVAL_DEREF(tmp); if (Z_TYPE_P(tmp) == IS_NULL) { params[i] = NULL; } else { @@ -2823,7 +2823,6 @@ static void php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, zend_long result_ if (ce->constructor) { fci.size = sizeof(fci); - fci.function_table = &ce->function_table; ZVAL_UNDEF(&fci.function_name); fci.object = Z_OBJ_P(return_value); fci.retval = &retval; @@ -2849,7 +2848,7 @@ static void php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, zend_long result_ fcc.initialized = 1; fcc.function_handler = ce->constructor; - fcc.calling_scope = EG(scope); + fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = Z_OBJCE_P(return_value); fcc.object = Z_OBJ_P(return_value); @@ -6185,8 +6184,11 @@ PHP_PGSQL_API int php_pgsql_convert(PGconn *pg_link, const char *table_name, con ZVAL_STRINGL(&new_val, "NULL", sizeof("NULL")-1); } else { - /* better regex? IPV6 and IPV4 */ - if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]).){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]).){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$", 0) == FAILURE) { + /* The inet type holds an IPv4 or IPv6 host address, and optionally its subnet, all in one field. See more in the doc. + The regex might still be not perfect, but catches the most of IP variants. We might decide to remove the regex + at all though and let the server side to handle it.*/ + if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])(\\/[0-9]{1,3})?$", 0) == FAILURE + && php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))(\\/[0-9]{1,3})?$", 0) == FAILURE) { err = 1; } else { @@ -6205,7 +6207,7 @@ PHP_PGSQL_API int php_pgsql_convert(PGconn *pg_link, const char *table_name, con } PGSQL_CONV_CHECK_IGNORE(); if (err) { - php_error_docref(NULL, E_NOTICE, "Expects NULL or string for '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field)); + php_error_docref(NULL, E_NOTICE, "Expects NULL or IPv4 or IPv6 address string for '%s' (%s)", Z_STRVAL_P(type), ZSTR_VAL(field)); } break; @@ -6220,7 +6222,7 @@ PHP_PGSQL_API int php_pgsql_convert(PGconn *pg_link, const char *table_name, con ZVAL_STRINGL(&new_val, "NOW()", sizeof("NOW()")-1); } else { /* better regex? */ - if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^([0-9]{4}[/-][0-9]{1,2}[/-][0-9]{1,2})([ \\t]+(([0-9]{1,2}:[0-9]{1,2}){1}(:[0-9]{1,2}){0,1}(\\.[0-9]+){0,1}([ \\t]*([+-][0-9]{1,4}(:[0-9]{1,2}){0,1}|[-a-zA-Z_/+]{1,50})){0,1})){0,1}$", 1) == FAILURE) { + if (php_pgsql_convert_match(Z_STRVAL_P(val), Z_STRLEN_P(val), "^([0-9]{4}[/-][0-9]{1,2}[/-][0-9]{1,2})(([ \\t]+|T)(([0-9]{1,2}:[0-9]{1,2}){1}(:[0-9]{1,2}){0,1}(\\.[0-9]+){0,1}([ \\t]*([+-][0-9]{1,4}(:[0-9]{1,2}){0,1}|[-a-zA-Z_/+]{1,50})){0,1})){0,1}$", 1) == FAILURE) { err = 1; } else { ZVAL_STRING(&new_val, Z_STRVAL_P(val)); diff --git a/ext/pgsql/tests/bug71062.phpt b/ext/pgsql/tests/bug71062.phpt new file mode 100644 index 0000000000..56e350daad --- /dev/null +++ b/ext/pgsql/tests/bug71062.phpt @@ -0,0 +1,39 @@ +--TEST-- +Bug #71062 pg_convert() doesn't accept ISO 8601 for datatype timestamp +--SKIPIF-- +<?php include("skipif.inc"); ?> +--FILE-- +<?php + +include('config.inc'); + +$db = pg_connect($conn_str); + +$table = "public.test_table_bug71062_bug71062"; + +pg_query($db, "CREATE TABLE $table ( test_field TIMESTAMPTZ )"); + +// ISO 8601 (with 'T' between date and time) +$date_string_php_iso8601 = date_create('8 Dec 2015 5:38')->format(DateTime::ISO8601); + +// ISO 8601 with the 'T' removed +$modified_format = 'Y-m-d H:i:sO'; +$date_string_modified_iso8601 = date_create('8 Dec 2015 5:38')->format($modified_format); + +printf("trying format %s \n", DateTime::ISO8601); +pg_convert($db, $table, ['test_field' => $date_string_php_iso8601]); + +printf("trying format %s \n", $modified_format); +pg_convert($db, $table, ['test_field' => $date_string_modified_iso8601]); + +print "done\n"; + +pg_query($db, "DROP TABLE $table"); + +?> +==OK== +--EXPECT-- +trying format Y-m-d\TH:i:sO +trying format Y-m-d H:i:sO +done +==OK== diff --git a/ext/pgsql/tests/bug71998.phpt b/ext/pgsql/tests/bug71998.phpt new file mode 100644 index 0000000000..b9924166f9 --- /dev/null +++ b/ext/pgsql/tests/bug71998.phpt @@ -0,0 +1,196 @@ +--TEST-- +Bug #71998 Function pg_insert does not insert when column type = inet +--SKIPIF-- +<?php include("skipif.inc"); ?> +--FILE-- +<?php +// Kudos for the IP regex to +// http://stackoverflow.com/a/17871737/3358424 + +include('config.inc'); + +$db = pg_connect($conn_str); + +pg_query("CREATE TABLE tmp_statistics (id integer NOT NULL, remote_addr inet);"); + +$ips = array( + /* IPv4*/ + "127.0.0.1", + "10.0.0.1", + "192.168.1.1", + "0.0.0.0", + "255.255.255.255", + "192.168.1.35/24", + + /* IPv6 */ + "::1", + "::10.2.3.4", + "::ffff:10.4.3.2", + "1:2:3:4:5:6:7:8", + "::ffff:10.0.0.1", + "::ffff:1.2.3.4", + "::ffff:0.0.0.0", + "1:2:3:4:5:6:77:88", + "::ffff:255.255.255.255", + "fe08::7:8", + "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", + "::5:aef1:ffff/128", + "2001:4f8:3:ba::/112", + +); + +$bad = array( + /* bad */ + "256.257.258.259", + "fe08::7:8interface", + "schnitzel", + "10002.3.4", + "1.2.3.4.5", + "256.0.0.0", + "260.0.0.0", +); + +$ips = array_merge($ips, $bad); +$i = 0; +$errors = 0; +foreach ($ips as $ip) { + $data = array("id" => ++$i, "remote_addr" => $ip); + $r = @pg_insert($db, 'tmp_statistics', $data); + + if (!$r && in_array($ip, $bad)) { + $errors++; + //echo pg_last_error($db); + } + + //pg_query($db, "INSERT INTO tmp_statistics (id, remote_addr) VALUES (2, '127.0.0.1')"); // OK, record inserted +} + + +$r = pg_query($db, "SELECT * FROM tmp_statistics"); +while (false != ($row = pg_fetch_row($r))) { + var_dump($row); +} +echo $errors, " errors catched\n"; + +pg_query($db, "DROP TABLE tmp_statistics"); +pg_close($db); + +?> +==DONE== +--EXPECT-- +array(2) { + [0]=> + string(1) "1" + [1]=> + string(9) "127.0.0.1" +} +array(2) { + [0]=> + string(1) "2" + [1]=> + string(8) "10.0.0.1" +} +array(2) { + [0]=> + string(1) "3" + [1]=> + string(11) "192.168.1.1" +} +array(2) { + [0]=> + string(1) "4" + [1]=> + string(7) "0.0.0.0" +} +array(2) { + [0]=> + string(1) "5" + [1]=> + string(15) "255.255.255.255" +} +array(2) { + [0]=> + string(1) "6" + [1]=> + string(15) "192.168.1.35/24" +} +array(2) { + [0]=> + string(1) "7" + [1]=> + string(3) "::1" +} +array(2) { + [0]=> + string(1) "8" + [1]=> + string(10) "::10.2.3.4" +} +array(2) { + [0]=> + string(1) "9" + [1]=> + string(15) "::ffff:10.4.3.2" +} +array(2) { + [0]=> + string(2) "10" + [1]=> + string(15) "1:2:3:4:5:6:7:8" +} +array(2) { + [0]=> + string(2) "11" + [1]=> + string(15) "::ffff:10.0.0.1" +} +array(2) { + [0]=> + string(2) "12" + [1]=> + string(14) "::ffff:1.2.3.4" +} +array(2) { + [0]=> + string(2) "13" + [1]=> + string(14) "::ffff:0.0.0.0" +} +array(2) { + [0]=> + string(2) "14" + [1]=> + string(17) "1:2:3:4:5:6:77:88" +} +array(2) { + [0]=> + string(2) "15" + [1]=> + string(22) "::ffff:255.255.255.255" +} +array(2) { + [0]=> + string(2) "16" + [1]=> + string(9) "fe08::7:8" +} +array(2) { + [0]=> + string(2) "17" + [1]=> + string(39) "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" +} +array(2) { + [0]=> + string(2) "18" + [1]=> + string(13) "::5:aef1:ffff" +} +array(2) { + [0]=> + string(2) "19" + [1]=> + string(19) "2001:4f8:3:ba::/112" +} +7 errors catched +==DONE== diff --git a/ext/pgsql/tests/bug72028.phpt b/ext/pgsql/tests/bug72028.phpt new file mode 100644 index 0000000000..217a03abc7 --- /dev/null +++ b/ext/pgsql/tests/bug72028.phpt @@ -0,0 +1,52 @@ +--TEST-- +Bug #72028 pg_query_params(): NULL converts to empty string +--SKIPIF-- +<?php include("skipif.inc"); ?> +--FILE-- +<?php +// create test table + +include('config.inc'); + +$conn = pg_connect($conn_str); + +$table = "bug72028_" . md5(uniqid(time())); + +pg_query("CREATE TABLE $table (value TEXT, details TEXT);"); + +$sql = "INSERT INTO $table (value, details) VALUES ($1, $2)"; + +$params = array(null, "insert before looping with a reference"); +$result = pg_query_params($conn, $sql, $params); + +$params2 = array(null, "insert after looping with a reference"); +foreach ($params2 as &$p) { + // doing nothing +} +unset($p); + +$result = pg_query_params($conn, $sql, $params2); + +$r = pg_query("SELECT * FROM $table"); +while (false !== ($i = pg_fetch_assoc($r))) { + var_dump($i); +} + +pg_query("DROP TABLE $table"); + +?> +==DONE== +--EXPECT-- +array(2) { + ["value"]=> + NULL + ["details"]=> + string(38) "insert before looping with a reference" +} +array(2) { + ["value"]=> + NULL + ["details"]=> + string(37) "insert after looping with a reference" +} +==DONE== diff --git a/ext/posix/posix.c b/ext/posix/posix.c index e1f4ef6262..771e316325 100644 --- a/ext/posix/posix.c +++ b/ext/posix/posix.c @@ -987,8 +987,12 @@ int php_posix_group_to_array(struct group *g, zval *array_group) /* {{{ */ array_init(&array_members); add_assoc_string(array_group, "name", g->gr_name); - add_assoc_string(array_group, "passwd", g->gr_passwd); - for (count=0; g->gr_mem[count] != NULL; count++) { + if (g->gr_passwd) { + add_assoc_string(array_group, "passwd", g->gr_passwd); + } else { + add_assoc_null(array_group, "passwd"); + } + for (count = 0; g->gr_mem[count] != NULL; count++) { add_next_index_string(&array_members, g->gr_mem[count]); } zend_hash_str_update(Z_ARRVAL_P(array_group), "members", sizeof("members")-1, &array_members); diff --git a/ext/readline/readline_cli.c b/ext/readline/readline_cli.c index 6f4e47d42b..2cce2292f4 100644 --- a/ext/readline/readline_cli.c +++ b/ext/readline/readline_cli.c @@ -106,7 +106,8 @@ static size_t readline_shell_ub_write(const char *str, size_t str_length) /* {{{ caller (sapi_cli_single_write in sapi/cli) which will actually write due to -1 return code */ php_last_char = str[str_length-1]; - return -1; + + return (size_t) -1; } /* }}} */ diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index dd3bd6e94d..2a7ff61957 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -456,8 +456,8 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in zend_class_constant *c; ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->constants_table, key, c) { - zval_update_constant_ex(&c->value, 1, NULL); - _class_const_string(str, ZSTR_VAL(key), c, indent); + zval_update_constant_ex(&c->value, c->ce); + _class_const_string(str, ZSTR_VAL(key), c, ZSTR_VAL(sub_indent.buf)); } ZEND_HASH_FOREACH_END(); } string_printf(str, "%s }\n", indent); @@ -633,11 +633,15 @@ static void _const_string(string *str, char *name, zval *value, char *indent) /* {{{ _class_const_string */ static void _class_const_string(string *str, char *name, zend_class_constant *c, char *indent) { - char *type = zend_zval_type_name(&c->value); char *visibility = zend_visibility_string(Z_ACCESS_FLAGS(c->value)); - zend_string *value_str = zval_get_string(&c->value); + zend_string *value_str; + char *type; - string_printf(str, "%s Constant [ %s %s %s ] { %s }\n", + zval_update_constant_ex(&c->value, c->ce); + value_str = zval_get_string(&c->value); + type = zend_zval_type_name(&c->value); + + string_printf(str, "%sConstant [ %s %s %s ] { %s }\n", indent, visibility, type, name, ZSTR_VAL(value_str)); zend_string_release(value_str); @@ -706,14 +710,10 @@ static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg zend_op *precv = _get_recv_op((zend_op_array*)fptr, offset); if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) { zval zv; - zend_class_entry *old_scope; string_write(str, " = ", sizeof(" = ")-1); ZVAL_DUP(&zv, RT_CONSTANT(&fptr->op_array, precv->op2)); - old_scope = EG(scope); - EG(scope) = fptr->common.scope; - zval_update_constant_ex(&zv, 1, NULL); - EG(scope) = old_scope; + zval_update_constant_ex(&zv, fptr->common.scope); if (Z_TYPE(zv) == IS_TRUE) { string_write(str, "true", sizeof("true")-1); } else if (Z_TYPE(zv) == IS_FALSE) { @@ -1428,7 +1428,6 @@ static void _reflection_export(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *c /* Call __construct() */ fci.size = sizeof(fci); - fci.function_table = NULL; ZVAL_UNDEF(&fci.function_name); fci.object = Z_OBJ(reflector); fci.retval = &retval; @@ -1461,7 +1460,6 @@ static void _reflection_export(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *c ZVAL_COPY_VALUE(¶ms[1], output_ptr); ZVAL_STRINGL(&fci.function_name, "reflection::export", sizeof("reflection::export") - 1); - fci.function_table = &reflection_ptr->function_table; fci.object = NULL; fci.retval = &retval; fci.param_count = 2; @@ -1933,7 +1931,7 @@ ZEND_METHOD(reflection_function, getStaticVariables) fptr->op_array.static_variables = zend_array_dup(fptr->op_array.static_variables); } ZEND_HASH_FOREACH_VAL(fptr->op_array.static_variables, val) { - if (UNEXPECTED(zval_update_constant_ex(val, 1, fptr->common.scope) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(val, fptr->common.scope) != SUCCESS)) { return; } } ZEND_HASH_FOREACH_END(); @@ -1962,7 +1960,6 @@ ZEND_METHOD(reflection_function, invoke) } fci.size = sizeof(fci); - fci.function_table = NULL; ZVAL_UNDEF(&fci.function_name); fci.object = NULL; fci.retval = &retval; @@ -1972,7 +1969,7 @@ ZEND_METHOD(reflection_function, invoke) fcc.initialized = 1; fcc.function_handler = fptr; - fcc.calling_scope = EG(scope); + fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = NULL; fcc.object = NULL; @@ -2021,7 +2018,6 @@ ZEND_METHOD(reflection_function, invokeArgs) } ZEND_HASH_FOREACH_END(); fci.size = sizeof(fci); - fci.function_table = NULL; ZVAL_UNDEF(&fci.function_name); fci.object = NULL; fci.retval = &retval; @@ -2031,7 +2027,7 @@ ZEND_METHOD(reflection_function, invokeArgs) fcc.initialized = 1; fcc.function_handler = fptr; - fcc.calling_scope = EG(scope); + fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = NULL; fcc.object = NULL; @@ -2892,15 +2888,9 @@ ZEND_METHOD(reflection_parameter, getDefaultValue) return; } - ZVAL_COPY_VALUE(return_value, RT_CONSTANT(¶m->fptr->op_array, precv->op2)); + ZVAL_DUP(return_value, RT_CONSTANT(¶m->fptr->op_array, precv->op2)); if (Z_CONSTANT_P(return_value)) { - zend_class_entry *old_scope = EG(scope); - - EG(scope) = param->fptr->common.scope; - zval_update_constant_ex(return_value, 0, NULL); - EG(scope) = old_scope; - } else { - zval_copy_ctor(return_value); + zval_update_constant_ex(return_value, param->fptr->common.scope); } } /* }}} */ @@ -3252,7 +3242,6 @@ ZEND_METHOD(reflection_method, invoke) } fci.size = sizeof(fci); - fci.function_table = NULL; ZVAL_UNDEF(&fci.function_name); fci.object = object; fci.retval = &retval; @@ -3358,7 +3347,6 @@ ZEND_METHOD(reflection_method, invokeArgs) } fci.size = sizeof(fci); - fci.function_table = NULL; ZVAL_UNDEF(&fci.function_name); fci.object = object ? Z_OBJ_P(object) : NULL; fci.retval = &retval; @@ -3837,6 +3825,9 @@ ZEND_METHOD(reflection_class_constant, getValue) GET_REFLECTION_OBJECT_PTR(ref); ZVAL_DUP(return_value, &ref->value); + if (Z_CONSTANT_P(return_value)) { + zval_update_constant_ex(return_value, ref->ce); + } } /* }}} */ @@ -3971,7 +3962,7 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value /* this is necessary to make it able to work with default array * properties, returned to user */ if (Z_CONSTANT(prop_copy)) { - if (UNEXPECTED(zval_update_constant_ex(&prop_copy, 1, NULL) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(&prop_copy, NULL) != SUCCESS)) { return; } } @@ -4627,7 +4618,7 @@ ZEND_METHOD(reflection_class, getConstants) GET_REFLECTION_OBJECT_PTR(ce); array_init(return_value); ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->constants_table, key, c) { - if (UNEXPECTED(zval_update_constant_ex(&c->value, 1, ce) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(&c->value, ce) != SUCCESS)) { zend_array_destroy(Z_ARRVAL_P(return_value)); return; } @@ -4675,7 +4666,7 @@ ZEND_METHOD(reflection_class, getConstant) GET_REFLECTION_OBJECT_PTR(ce); ZEND_HASH_FOREACH_PTR(&ce->constants_table, c) { - if (UNEXPECTED(zval_update_constant_ex(&c->value, 1, ce) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(&c->value, ce) != SUCCESS)) { return; } } ZEND_HASH_FOREACH_END(); @@ -4862,10 +4853,10 @@ ZEND_METHOD(reflection_class, newInstance) return; } - old_scope = EG(scope); - EG(scope) = ce; + old_scope = EG(fake_scope); + EG(fake_scope) = ce; constructor = Z_OBJ_HT_P(return_value)->get_constructor(Z_OBJ_P(return_value)); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; /* Run the constructor if there is one */ if (constructor) { @@ -4890,7 +4881,6 @@ ZEND_METHOD(reflection_class, newInstance) } fci.size = sizeof(fci); - fci.function_table = EG(function_table); ZVAL_UNDEF(&fci.function_name); fci.object = Z_OBJ_P(return_value); fci.retval = &retval; @@ -4900,7 +4890,7 @@ ZEND_METHOD(reflection_class, newInstance) fcc.initialized = 1; fcc.function_handler = constructor; - fcc.calling_scope = EG(scope); + fcc.calling_scope = zend_get_executed_scope();; fcc.called_scope = Z_OBJCE_P(return_value); fcc.object = Z_OBJ_P(return_value); @@ -4966,10 +4956,10 @@ ZEND_METHOD(reflection_class, newInstanceArgs) return; } - old_scope = EG(scope); - EG(scope) = ce; + old_scope = EG(fake_scope); + EG(fake_scope) = ce; constructor = Z_OBJ_HT_P(return_value)->get_constructor(Z_OBJ_P(return_value)); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; /* Run the constructor if there is one */ if (constructor) { @@ -4993,7 +4983,6 @@ ZEND_METHOD(reflection_class, newInstanceArgs) } fci.size = sizeof(fci); - fci.function_table = EG(function_table); ZVAL_UNDEF(&fci.function_name); fci.object = Z_OBJ_P(return_value); fci.retval = &retval; @@ -5003,7 +4992,7 @@ ZEND_METHOD(reflection_class, newInstanceArgs) fcc.initialized = 1; fcc.function_handler = constructor; - fcc.calling_scope = EG(scope); + fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = Z_OBJCE_P(return_value); fcc.object = Z_OBJ_P(return_value); @@ -5647,7 +5636,9 @@ ZEND_METHOD(reflection_property, getValue) php_error_docref(NULL, E_ERROR, "Internal error: Could not find the property %s::%s", ZSTR_VAL(intern->ce->name), ZSTR_VAL(ref->prop.name)); /* Bails out */ } - ZVAL_DUP(return_value, &CE_STATIC_MEMBERS(intern->ce)[ref->prop.offset]); + member_p = &CE_STATIC_MEMBERS(intern->ce)[ref->prop.offset]; + ZVAL_DEREF(member_p); + ZVAL_COPY(return_value, member_p); } else { const char *class_name, *prop_name; size_t prop_name_len; @@ -5659,7 +5650,8 @@ ZEND_METHOD(reflection_property, getValue) zend_unmangle_property_name_ex(ref->prop.name, &class_name, &prop_name, &prop_name_len); member_p = zend_read_property(ref->ce, object, prop_name, prop_name_len, 1, &rv); - ZVAL_DUP(return_value, member_p); + ZVAL_DEREF(member_p); + ZVAL_COPY(return_value, member_p); } } /* }}} */ diff --git a/ext/reflection/tests/ReflectionClassConstant_basic1.phpt b/ext/reflection/tests/ReflectionClassConstant_basic1.phpt index 3d4f49f144..fd8118650f 100644 --- a/ext/reflection/tests/ReflectionClassConstant_basic1.phpt +++ b/ext/reflection/tests/ReflectionClassConstant_basic1.phpt @@ -53,13 +53,13 @@ reflectClassConstant($instance, "BAD_CONST"); Reflecting on class constant TestClass::PUB __toString(): -string(42) " Constant [ public boolean PUB ] { 1 } +string(38) "Constant [ public boolean PUB ] { 1 } " export(): -string(42) " Constant [ public boolean PUB ] { 1 } +string(38) "Constant [ public boolean PUB ] { 1 } " export(): - Constant [ public boolean PUB ] { 1 } +Constant [ public boolean PUB ] { 1 } NULL getName(): @@ -87,13 +87,13 @@ string(21) "/** My Doc comment */" Reflecting on class constant TestClass::PROT __toString(): -string(46) " Constant [ protected integer PROT ] { 4 } +string(42) "Constant [ protected integer PROT ] { 4 } " export(): -string(46) " Constant [ protected integer PROT ] { 4 } +string(42) "Constant [ protected integer PROT ] { 4 } " export(): - Constant [ protected integer PROT ] { 4 } +Constant [ protected integer PROT ] { 4 } NULL getName(): @@ -121,13 +121,13 @@ string(26) "/** Another doc comment */" Reflecting on class constant TestClass::PRIV __toString(): -string(49) " Constant [ private string PRIV ] { keepOut } +string(45) "Constant [ private string PRIV ] { keepOut } " export(): -string(49) " Constant [ private string PRIV ] { keepOut } +string(45) "Constant [ private string PRIV ] { keepOut } " export(): - Constant [ private string PRIV ] { keepOut } +Constant [ private string PRIV ] { keepOut } NULL getName(): @@ -155,13 +155,13 @@ bool(false) Reflecting on class constant TestClass::PRIV __toString(): -string(49) " Constant [ private string PRIV ] { keepOut } +string(45) "Constant [ private string PRIV ] { keepOut } " export(): -string(49) " Constant [ private string PRIV ] { keepOut } +string(45) "Constant [ private string PRIV ] { keepOut } " export(): - Constant [ private string PRIV ] { keepOut } +Constant [ private string PRIV ] { keepOut } NULL getName(): diff --git a/ext/reflection/tests/ReflectionClassConstant_getValue.phpt b/ext/reflection/tests/ReflectionClassConstant_getValue.phpt new file mode 100644 index 0000000000..e447d15357 --- /dev/null +++ b/ext/reflection/tests/ReflectionClassConstant_getValue.phpt @@ -0,0 +1,47 @@ +--TEST-- +Test variations of getting constant values +--FILE-- +<?php + +/* Use separate classes to make sure that in-place constant updates don't interfere */ +class A { + const X = self::Y * 2; + const Y = 1; +} +class B { + const X = self::Y * 2; + const Y = 1; +} +class C { + const X = self::Y * 2; + const Y = 1; +} + +var_dump((new ReflectionClassConstant('A', 'X'))->getValue()); +echo new ReflectionClassConstant('B', 'X'); +echo new ReflectionClass('C'); + +?> +--EXPECTF-- +int(2) +Constant [ public integer X ] { 2 } +Class [ <user> class C ] { + @@ %s 12-15 + + - Constants [2] { + Constant [ public integer X ] { 2 } + Constant [ public integer Y ] { 1 } + } + + - Static properties [0] { + } + + - Static methods [0] { + } + + - Properties [0] { + } + + - Methods [0] { + } +} diff --git a/ext/session/session.c b/ext/session/session.c index 79d5dd2831..6fd0ee2f37 100644 --- a/ext/session/session.c +++ b/ext/session/session.c @@ -500,7 +500,6 @@ static void php_session_gc(void) /* {{{ */ } } /* }}} */ - static void php_session_initialize(void) /* {{{ */ { zend_string *val = NULL; @@ -627,6 +626,22 @@ static void php_session_save_current_state(int write) /* {{{ */ } /* }}} */ +static void php_session_normalize_vars() /* {{{ */ +{ + PS_ENCODE_VARS; + + IF_SESSION_VARS() { + PS_ENCODE_LOOP( + if (Z_TYPE_P(struc) == IS_PTR) { + zval *zv = (zval *)Z_PTR_P(struc); + ZVAL_COPY_VALUE(struc, zv); + ZVAL_UNDEF(zv); + } + ); + } +} +/* }}} */ + /* ************************* * INI Settings/Handlers * ************************* */ @@ -958,7 +973,6 @@ PS_SERIALIZER_DECODE_FUNC(php_binary) /* {{{ */ { const char *p; const char *endptr = val + vallen; - zval current; int has_value; int namelen; zend_string *name; @@ -981,28 +995,32 @@ PS_SERIALIZER_DECODE_FUNC(php_binary) /* {{{ */ p += namelen + 1; if ((tmp = zend_hash_find(&EG(symbol_table), name))) { - if ((Z_TYPE_P(tmp) == IS_ARRAY && Z_ARRVAL_P(tmp) == &EG(symbol_table)) || tmp == &PS(http_session_vars)) { + if ((Z_TYPE_P(tmp) == IS_ARRAY && + Z_ARRVAL_P(tmp) == &EG(symbol_table)) || tmp == &PS(http_session_vars)) { zend_string_release(name); continue; } } if (has_value) { - ZVAL_UNDEF(¤t); - if (php_var_unserialize(¤t, (const unsigned char **) &p, (const unsigned char *) endptr, &var_hash)) { - zval *zv = php_set_session_var(name, ¤t, &var_hash ); - var_replace(&var_hash, ¤t, zv); + zval *current, rv; + current = var_tmp_var(&var_hash); + if (php_var_unserialize(current, (const unsigned char **) &p, (const unsigned char *) endptr, &var_hash)) { + ZVAL_PTR(&rv, current); + php_set_session_var(name, &rv, &var_hash ); } else { - zval_ptr_dtor(¤t); zend_string_release(name); + php_session_normalize_vars(); PHP_VAR_UNSERIALIZE_DESTROY(var_hash); return FAILURE; } + } else { + PS_ADD_VARL(name); } - PS_ADD_VARL(name); zend_string_release(name); } + php_session_normalize_vars(); PHP_VAR_UNSERIALIZE_DESTROY(var_hash); return SUCCESS; @@ -1047,10 +1065,9 @@ PS_SERIALIZER_DECODE_FUNC(php) /* {{{ */ { const char *p, *q; const char *endptr = val + vallen; - zval current; - int has_value; ptrdiff_t namelen; zend_string *name; + int has_value, retval = SUCCESS; php_unserialize_data_t var_hash; PHP_VAR_UNSERIALIZE_INIT(var_hash); @@ -1075,34 +1092,37 @@ PS_SERIALIZER_DECODE_FUNC(php) /* {{{ */ q++; if ((tmp = zend_hash_find(&EG(symbol_table), name))) { - if ((Z_TYPE_P(tmp) == IS_ARRAY && Z_ARRVAL_P(tmp) == &EG(symbol_table)) || tmp == &PS(http_session_vars)) { + if ((Z_TYPE_P(tmp) == IS_ARRAY && + Z_ARRVAL_P(tmp) == &EG(symbol_table)) || tmp == &PS(http_session_vars)) { goto skip; } } if (has_value) { - ZVAL_UNDEF(¤t); - if (php_var_unserialize(¤t, (const unsigned char **) &q, (const unsigned char *) endptr, &var_hash)) { - zval *zv = php_set_session_var(name, ¤t, &var_hash); - var_replace(&var_hash, ¤t, zv); + zval *current, rv; + current = var_tmp_var(&var_hash); + if (php_var_unserialize(current, (const unsigned char **)&q, (const unsigned char *)endptr, &var_hash)) { + ZVAL_PTR(&rv, current); + php_set_session_var(name, &rv, &var_hash); } else { - zval_ptr_dtor(¤t); - PHP_VAR_UNSERIALIZE_DESTROY(var_hash); zend_string_release(name); - return FAILURE; + retval = FAILURE; + goto break_outer_loop; } + } else { + PS_ADD_VARL(name); } - PS_ADD_VARL(name); skip: zend_string_release(name); p = q; } break_outer_loop: + php_session_normalize_vars(); PHP_VAR_UNSERIALIZE_DESTROY(var_hash); - return SUCCESS; + return retval; } /* }}} */ diff --git a/ext/session/tests/bug71972.phpt b/ext/session/tests/bug71972.phpt new file mode 100644 index 0000000000..e4c5c6b6d3 --- /dev/null +++ b/ext/session/tests/bug71972.phpt @@ -0,0 +1,28 @@ +--TEST-- +Bug #71972 (Cyclic references causing session_start(): Failed to decode session object) +--SKIPIF-- +<?php include('skipif.inc'); ?> +--INI-- +session.save_handler=files +--FILE-- +<?php +ob_start(); +session_start(); + +$_SESSION['boogie'] = 1; + +$_SESSION['obj1'] = new stdClass(); +for ( $x=2; $x < 20; $x++) { + cyclic_ref($x); +} + +function cyclic_ref($num) { + $_SESSION['obj'.$num] = new stdClass(); + $_SESSION['obj'.$num]->test = new stdClass();//NOTE: No bug if try commenting out this too. + $_SESSION['obj'.$num]->obj1 = $_SESSION['obj1']; +} + +var_dump(session_decode(session_encode()) == $_SESSION); +?> +--EXPECT-- +bool(true) diff --git a/ext/soap/php_encoding.c b/ext/soap/php_encoding.c index fc389f2365..803a5cd596 100644 --- a/ext/soap/php_encoding.c +++ b/ext/soap/php_encoding.c @@ -1164,13 +1164,8 @@ static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNode static void set_zval_property(zval* object, char* name, zval* val) { - zend_class_entry *old_scope; - - old_scope = EG(scope); - EG(scope) = Z_OBJCE_P(object); - add_property_zval(object, name, val); + zend_update_property(Z_OBJCE_P(object), object, name, strlen(name), val); if (Z_REFCOUNTED_P(val)) Z_DELREF_P(val); - EG(scope) = old_scope; } static zval* get_zval_property(zval* object, char* name, zval *rv) @@ -1181,15 +1176,15 @@ static zval* get_zval_property(zval* object, char* name, zval *rv) zend_class_entry *old_scope; ZVAL_STRING(&member, name); - old_scope = EG(scope); - EG(scope) = Z_OBJCE_P(object); + old_scope = EG(fake_scope); + EG(fake_scope) = Z_OBJCE_P(object); data = Z_OBJ_HT_P(object)->read_property(object, &member, BP_VAR_IS, NULL, rv); if (data == &EG(uninitialized_zval)) { /* Hack for bug #32455 */ zend_property_info *property_info; property_info = zend_get_property_info(Z_OBJCE_P(object), Z_STR(member), 1); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; if (property_info != ZEND_WRONG_PROPERTY_INFO && property_info && zend_hash_exists(Z_OBJPROP_P(object), property_info->name)) { zval_ptr_dtor(&member); @@ -1199,7 +1194,7 @@ static zval* get_zval_property(zval* object, char* name, zval *rv) return NULL; } zval_ptr_dtor(&member); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; return data; } else if (Z_TYPE_P(object) == IS_ARRAY) { zval *data_ptr; @@ -1218,10 +1213,10 @@ static void unset_zval_property(zval* object, char* name) zend_class_entry *old_scope; ZVAL_STRING(&member, name); - old_scope = EG(scope); - EG(scope) = Z_OBJCE_P(object); + old_scope = EG(fake_scope); + EG(fake_scope) = Z_OBJCE_P(object); Z_OBJ_HT_P(object)->unset_property(object, &member, NULL); - EG(scope) = old_scope; + EG(fake_scope) = old_scope; zval_ptr_dtor(&member); } else if (Z_TYPE_P(object) == IS_ARRAY) { zend_hash_str_del(Z_ARRVAL_P(object), name, strlen(name)); diff --git a/ext/soap/soap.c b/ext/soap/soap.c index fcfa2511eb..c842ce5119 100644 --- a/ext/soap/soap.c +++ b/ext/soap/soap.c @@ -953,7 +953,6 @@ PHP_METHOD(SoapFault, __toString) line = zend_read_property(soap_fault_class_entry, this_ptr, "line", sizeof("line")-1, 1, &rv4); fci.size = sizeof(fci); - fci.function_table = &Z_OBJCE_P(getThis())->function_table; ZVAL_STRINGL(&fci.function_name, "gettraceasstring", sizeof("gettraceasstring")-1); fci.object = Z_OBJ(EX(This)); fci.retval = &trace; diff --git a/ext/sockets/sockets.c b/ext/sockets/sockets.c index 6039ac65ba..63674c50d7 100644 --- a/ext/sockets/sockets.c +++ b/ext/sockets/sockets.c @@ -251,6 +251,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_import_stream, 0, 0, 1) ZEND_ARG_INFO(0, stream) ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_export_stream, 0, 0, 1) + ZEND_ARG_INFO(0, socket) +ZEND_END_ARG_INFO() + ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_sendmsg, 0, 0, 3) ZEND_ARG_INFO(0, socket) ZEND_ARG_INFO(0, msghdr) @@ -305,6 +309,7 @@ PHP_FUNCTION(socket_shutdown); PHP_FUNCTION(socket_last_error); PHP_FUNCTION(socket_clear_error); PHP_FUNCTION(socket_import_stream); +PHP_FUNCTION(socket_export_stream); /* {{{ sockets_functions[] */ @@ -339,6 +344,7 @@ const zend_function_entry sockets_functions[] = { PHP_FE(socket_last_error, arginfo_socket_last_error) PHP_FE(socket_clear_error, arginfo_socket_clear_error) PHP_FE(socket_import_stream, arginfo_socket_import_stream) + PHP_FE(socket_export_stream, arginfo_socket_export_stream) PHP_FE(socket_sendmsg, arginfo_socket_sendmsg) PHP_FE(socket_recvmsg, arginfo_socket_recvmsg) PHP_FE(socket_cmsg_space, arginfo_socket_cmsg_space) @@ -2307,7 +2313,7 @@ error: return NULL; } -/* {{{ proto void socket_import_stream(resource stream) +/* {{{ proto resource socket_import_stream(resource stream) Imports a stream that encapsulates a socket into a socket extension resource. */ PHP_FUNCTION(socket_import_stream) { @@ -2343,8 +2349,7 @@ PHP_FUNCTION(socket_import_stream) #endif /* hold a zval reference to the stream (holding a php_stream* directly could - * also be done, but this might be slightly better if in the future we want - * to provide a socket_export_stream) */ + * also be done, but this makes socket_export_stream a bit simpler) */ ZVAL_COPY(&retsock->zstream, zstream); php_stream_set_option(stream, PHP_STREAM_OPTION_READ_BUFFER, @@ -2354,6 +2359,103 @@ PHP_FUNCTION(socket_import_stream) } /* }}} */ +/* {{{ proto resource socket_export_stream(resource socket) + Exports a socket extension resource into a stream that encapsulates a socket. */ +PHP_FUNCTION(socket_export_stream) +{ + zval *zsocket; + php_socket *socket; + php_stream *stream = NULL; + php_netstream_data_t *stream_data; + char *protocol = NULL; + size_t protocollen = 0; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zsocket) == FAILURE) { + return; + } + if ((socket = (php_socket *) zend_fetch_resource(Z_RES_P(zsocket), le_socket_name, le_socket)) == NULL) { + RETURN_FALSE; + } + + /* Either we already exported a stream or the socket came from an import, + * just return the existing stream */ + if (!Z_ISUNDEF(socket->zstream)) { + RETURN_ZVAL(&socket->zstream, 1, 0); + } + + /* Determine if socket is using a protocol with one of the default registered + * socket stream wrappers */ + if (socket->type == PF_INET +#if HAVE_IPV6 + || socket->type == PF_INET6 +#endif + ) { + int protoid; + socklen_t protoidlen = sizeof(protoid); + + getsockopt(socket->bsd_socket, SOL_SOCKET, SO_TYPE, (char *) &protoid, &protoidlen); + + if (protoid == SOCK_STREAM) { + /* SO_PROTOCOL is not (yet?) supported on OS X, so lets assume it's TCP there */ +#ifdef SO_PROTOCOL + protoidlen = sizeof(protoid); + getsockopt(socket->bsd_socket, SOL_SOCKET, SO_PROTOCOL, (char *) &protoid, &protoidlen); + if (protoid == IPPROTO_TCP) +#endif + { + protocol = "tcp"; + protocollen = 3; + } + } else if (protoid == SOCK_DGRAM) { + protocol = "udp"; + protocollen = 3; + } +#ifdef PF_UNIX + } else if (socket->type == PF_UNIX) { + int type; + socklen_t typelen = sizeof(type); + + getsockopt(socket->bsd_socket, SOL_SOCKET, SO_TYPE, (char *) &type, &typelen); + + if (type == SOCK_STREAM) { + protocol = "unix"; + protocollen = 4; + } else if (type == SOCK_DGRAM) { + protocol = "udg"; + protocollen = 3; + } +#endif + } + + /* Try to get a stream with the registered sockops for the protocol in use + * We don't want streams to actually *do* anything though, so don't give it + * anything apart from the protocol */ + if (protocol != NULL) { + stream = php_stream_xport_create(protocol, protocollen, 0, 0, NULL, NULL, NULL, NULL, NULL); + } + + /* Fall back to creating a generic socket stream */ + if (stream == NULL) { + stream = php_stream_sock_open_from_socket(socket->bsd_socket, 0); + + if (stream == NULL) { + php_error_docref(NULL, E_WARNING, "failed to create stream"); + RETURN_FALSE; + } + } + + stream_data = (php_netstream_data_t *) stream->abstract; + stream_data->socket = socket->bsd_socket; + stream_data->is_blocked = socket->blocking; + stream_data->timeout.tv_sec = FG(default_socket_timeout); + stream_data->timeout.tv_usec = 0; + + php_stream_to_zval(stream, &socket->zstream); + + RETURN_ZVAL(&socket->zstream, 1, 0); +} +/* }}} */ + /* * Local variables: * tab-width: 4 diff --git a/ext/sockets/tests/socket_export_stream-1.phpt b/ext/sockets/tests/socket_export_stream-1.phpt new file mode 100644 index 0000000000..498e0a277c --- /dev/null +++ b/ext/sockets/tests/socket_export_stream-1.phpt @@ -0,0 +1,27 @@ +--TEST-- +socket_export_stream: Basic test +--SKIPIF-- +<?php +if (!extension_loaded('sockets')) { + die('SKIP sockets extension not available.'); +} + +--FILE-- +<?php + +$domain = (strtoupper(substr(PHP_OS, 0, 3) == 'WIN') ? AF_INET : AF_UNIX); +socket_create_pair($domain, SOCK_STREAM, 0, $s); + +$s0 = reset($s); +$s1 = next($s); + +$stream = socket_export_stream($s0); +var_dump($stream); + +socket_write($s1, "test message"); +socket_close($s1); + +var_dump(stream_get_contents($stream)); +--EXPECTF-- +resource(%d) of type (stream) +string(12) "test message" diff --git a/ext/sockets/tests/socket_export_stream-2.phpt b/ext/sockets/tests/socket_export_stream-2.phpt new file mode 100644 index 0000000000..98528420fa --- /dev/null +++ b/ext/sockets/tests/socket_export_stream-2.phpt @@ -0,0 +1,48 @@ +--TEST-- +socket_export_stream: Bad arguments +--SKIPIF-- +<?php +if (!extension_loaded('sockets')) { + die('SKIP sockets extension not available.'); +} + +--FILE-- +<?php + +var_dump(socket_export_stream()); +var_dump(socket_export_stream(1, 2)); +var_dump(socket_export_stream(1)); +var_dump(socket_export_stream(new stdclass)); +var_dump(socket_export_stream(fopen(__FILE__, "rb"))); +var_dump(socket_export_stream(stream_socket_server("udp://127.0.0.1:58392", $errno, $errstr, STREAM_SERVER_BIND))); +$s = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +var_dump($s); +socket_close($s); +var_dump(socket_export_stream($s)); + + +echo "Done."; +--EXPECTF-- +Warning: socket_export_stream() expects exactly 1 parameter, 0 given in %s on line %d +NULL + +Warning: socket_export_stream() expects exactly 1 parameter, 2 given in %s on line %d +NULL + +Warning: socket_export_stream() expects parameter 1 to be resource, integer given in %s on line %d +NULL + +Warning: socket_export_stream() expects parameter 1 to be resource, object given in %s on line %d +NULL + +Warning: socket_export_stream(): supplied resource is not a valid Socket resource in %s on line %d +bool(false) + +Warning: socket_export_stream(): supplied resource is not a valid Socket resource in %s on line %d +bool(false) +resource(%d) of type (Socket) + +Warning: socket_export_stream(): supplied resource is not a valid Socket resource in %s on line %d +bool(false) +Done. + diff --git a/ext/sockets/tests/socket_export_stream-3.phpt b/ext/sockets/tests/socket_export_stream-3.phpt new file mode 100644 index 0000000000..b13bb34739 --- /dev/null +++ b/ext/sockets/tests/socket_export_stream-3.phpt @@ -0,0 +1,47 @@ +--TEST-- +socket_export_stream: Test with multicasting +--SKIPIF-- +<?php +if (!extension_loaded('sockets')) { + die('SKIP sockets extension not available.'); +} +$s = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +$br = socket_bind($s, '0.0.0.0', 58381); +if ($br === false) + die("SKIP IPv4/port 58381 not available"); +$so = socket_set_option($s, IPPROTO_IP, MCAST_JOIN_GROUP, array( + "group" => '224.0.0.23', + "interface" => "lo", +)); +if ($so === false) + die("SKIP joining group 224.0.0.23 on interface lo failed"); +--FILE-- +<?php + +$sock = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock, '0.0.0.0', 58381); +$stream = socket_export_stream($sock); +var_dump($stream); +$so = socket_set_option($sock, IPPROTO_IP, MCAST_JOIN_GROUP, array( + "group" => '224.0.0.23', + "interface" => "lo", +)); +var_dump($so); + +$sendsock = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +var_dump($sendsock); +$br = socket_bind($sendsock, '127.0.0.1'); +$so = socket_sendto($sendsock, $m = "my message", strlen($m), 0, "224.0.0.23", 58381); +var_dump($so); + +stream_set_blocking($stream, 0); +var_dump(fread($stream, strlen($m))); +echo "Done.\n"; +--EXPECTF-- +resource(%d) of type (stream) +bool(true) +resource(%d) of type (Socket) +int(10) +string(10) "my message" +Done. + diff --git a/ext/sockets/tests/socket_export_stream-4-win.phpt b/ext/sockets/tests/socket_export_stream-4-win.phpt new file mode 100644 index 0000000000..e38db7bd08 --- /dev/null +++ b/ext/sockets/tests/socket_export_stream-4-win.phpt @@ -0,0 +1,108 @@ +--TEST-- +socket_export_stream: effects of closing +--SKIPIF-- +<?php +if (!extension_loaded('sockets')) { + die('SKIP sockets extension not available.'); +} +if(substr(PHP_OS, 0, 3) != 'WIN' ) { + die("skip Not Valid for Linux"); +} + +--FILE-- +<?php + +function test($stream, $sock) { + if ($stream !== null) { + echo "stream_set_blocking "; + print_r(stream_set_blocking($stream, 0)); + echo "\n"; + } + if ($sock !== null) { + echo "socket_set_block "; + print_r(socket_set_block($sock)); + echo "\n"; + echo "socket_get_option "; + print_r(socket_get_option($sock, SOL_SOCKET, SO_TYPE)); + echo "\n"; + } + echo "\n"; +} + +echo "normal\n"; +$sock0 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock0, '0.0.0.0', 58380); +$stream0 = socket_export_stream($sock0); +test($stream0, $sock0); + +echo "\nunset stream\n"; +$sock1 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock1, '0.0.0.0', 58381); +$stream1 = socket_export_stream($sock1); +unset($stream1); +test(null, $sock1); + +echo "\nunset socket\n"; +$sock2 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock2, '0.0.0.0', 58382); +$stream2 = socket_export_stream($sock2); +unset($sock2); +test($stream2, null); + +echo "\nclose stream\n"; +$sock3 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock3, '0.0.0.0', 58383); +$stream3 = socket_export_stream($sock3); +fclose($stream3); +test($stream3, $sock3); + +echo "\nclose socket\n"; +$sock4 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock4, '0.0.0.0', 58484); +$stream4 = socket_export_stream($sock4); +socket_close($sock4); +test($stream4, $sock4); + +echo "Done.\n"; +--EXPECTF-- +normal +stream_set_blocking 1 +socket_set_block 1 +socket_get_option 2 + + +unset stream +socket_set_block 1 +socket_get_option 2 + + +unset socket +stream_set_blocking 1 + + +close stream +stream_set_blocking +Warning: stream_set_blocking(): supplied resource is not a valid stream resource in %s on line %d + +socket_set_block +Warning: socket_set_block(): unable to set blocking mode [%d]: An operation was attempted on something that is not a socket. + in %s on line %d + +socket_get_option +Warning: socket_get_option(): unable to retrieve socket option [%d]: An operation was attempted on something that is not a socket. + in %s on line %d + + + +close socket +stream_set_blocking +Warning: stream_set_blocking(): supplied resource is not a valid stream resource in %s on line %d + +socket_set_block +Warning: socket_set_block(): supplied resource is not a valid Socket resource in %s on line %d + +socket_get_option +Warning: socket_get_option(): supplied resource is not a valid Socket resource in %s on line %d + + +Done. diff --git a/ext/sockets/tests/socket_export_stream-4.phpt b/ext/sockets/tests/socket_export_stream-4.phpt new file mode 100644 index 0000000000..ff329ec795 --- /dev/null +++ b/ext/sockets/tests/socket_export_stream-4.phpt @@ -0,0 +1,105 @@ +--TEST-- +socket_export_stream: effects of closing +--SKIPIF-- +<?php +if (!extension_loaded('sockets')) { + die('SKIP sockets extension not available.'); +} +if(substr(PHP_OS, 0, 3) == 'WIN' ) { + die("skip Not Valid for Windows"); +} +--FILE-- +<?php + +function test($stream, $sock) { + if ($stream !== null) { + echo "stream_set_blocking "; + print_r(stream_set_blocking($stream, 0)); + echo "\n"; + } + if ($sock !== null) { + echo "socket_set_block "; + print_r(socket_set_block($sock)); + echo "\n"; + echo "socket_get_option "; + print_r(socket_get_option($sock, SOL_SOCKET, SO_TYPE)); + echo "\n"; + } + echo "\n"; +} + +echo "normal\n"; +$sock0 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock0, '0.0.0.0', 58380); +$stream0 = socket_export_stream($sock0); +test($stream0, $sock0); + +echo "\nunset stream\n"; +$sock1 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock1, '0.0.0.0', 58381); +$stream1 = socket_export_stream($sock1); +unset($stream1); +test(null, $sock1); + +echo "\nunset socket\n"; +$sock2 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock2, '0.0.0.0', 58382); +$stream2 = socket_export_stream($sock2); +unset($sock2); +test($stream2, null); + +echo "\nclose stream\n"; +$sock3 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock3, '0.0.0.0', 58383); +$stream3 = socket_export_stream($sock3); +fclose($stream3); +test($stream3, $sock3); + +echo "\nclose socket\n"; +$sock4 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock4, '0.0.0.0', 58484); +$stream4 = socket_export_stream($sock4); +socket_close($sock4); +test($stream4, $sock4); + +echo "Done.\n"; +--EXPECTF-- +normal +stream_set_blocking 1 +socket_set_block 1 +socket_get_option 2 + + +unset stream +socket_set_block 1 +socket_get_option 2 + + +unset socket +stream_set_blocking 1 + + +close stream +stream_set_blocking +Warning: stream_set_blocking(): supplied resource is not a valid stream resource in %s on line %d + +socket_set_block +Warning: socket_set_block(): unable to set blocking mode [%d]: %s in %s on line %d + +socket_get_option +Warning: socket_get_option(): unable to retrieve socket option [%d]: %s in %s on line %d + + + +close socket +stream_set_blocking +Warning: stream_set_blocking(): supplied resource is not a valid stream resource in %s on line %d + +socket_set_block +Warning: socket_set_block(): supplied resource is not a valid Socket resource in %s on line %d + +socket_get_option +Warning: socket_get_option(): supplied resource is not a valid Socket resource in %s on line %d + + +Done. diff --git a/ext/sockets/tests/socket_export_stream-5.phpt b/ext/sockets/tests/socket_export_stream-5.phpt new file mode 100644 index 0000000000..732b2072d0 --- /dev/null +++ b/ext/sockets/tests/socket_export_stream-5.phpt @@ -0,0 +1,25 @@ +--TEST-- +socket_export_stream: effects of leaked handles +--SKIPIF-- +<?php +if (!extension_loaded('sockets')) { + die('SKIP sockets extension not available.'); +} +if (!function_exists('leak_variable')) + die('SKIP only for debug builds'); +--FILE-- +<?php + +$sock0 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock0, '0.0.0.0', 58380); +$stream0 = socket_export_stream($sock0); +leak_variable($stream0, true); + +$sock1 = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); +socket_bind($sock1, '0.0.0.0', 58381); +$stream1 = socket_export_stream($sock1); +leak_variable($sock1, true); + +echo "Done.\n"; +--EXPECT-- +Done. diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c index 2a1df40fbb..fdae966023 100644 --- a/ext/spl/spl_directory.c +++ b/ext/spl/spl_directory.c @@ -2075,7 +2075,6 @@ static int spl_filesystem_file_call(spl_filesystem_object *intern, zend_function ZVAL_UNDEF(&retval); fci.size = sizeof(fci); - fci.function_table = EG(function_table); fci.object = NULL; fci.retval = &retval; fci.param_count = num_args; @@ -2883,7 +2882,7 @@ SPL_METHOD(SplFileObject, fwrite) if (ZEND_NUM_ARGS() > 1) { if (length >= 0) { - str_len = MAX(0, MIN((size_t)length, str_len)); + str_len = MIN((size_t)length, str_len); } else { /* Negative length given, nothing to write */ str_len = 0; diff --git a/ext/spl/spl_engine.h b/ext/spl/spl_engine.h index 0ee23cac1c..b683c16d94 100644 --- a/ext/spl/spl_engine.h +++ b/ext/spl/spl_engine.h @@ -62,7 +62,6 @@ static inline void spl_instantiate_arg_n(zend_class_entry *pce, zval *retval, in spl_instantiate(pce, retval); fci.size = sizeof(zend_fcall_info); - fci.function_table = &pce->function_table; ZVAL_STR(&fci.function_name, func->common.function_name); fci.object = Z_OBJ_P(retval); fci.retval = &dummy; @@ -72,7 +71,7 @@ static inline void spl_instantiate_arg_n(zend_class_entry *pce, zval *retval, in fcc.initialized = 1; fcc.function_handler = func; - fcc.calling_scope = EG(scope); + fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = pce; fcc.object = Z_OBJ_P(retval); diff --git a/ext/spl/spl_fixedarray.c b/ext/spl/spl_fixedarray.c index 9bbda05829..e04abf77ea 100644 --- a/ext/spl/spl_fixedarray.c +++ b/ext/spl/spl_fixedarray.c @@ -410,11 +410,11 @@ static inline void spl_fixedarray_object_write_dimension_helper(spl_fixedarray_o static void spl_fixedarray_object_write_dimension(zval *object, zval *offset, zval *value) /* {{{ */ { spl_fixedarray_object *intern; + zval tmp; intern = Z_SPLFIXEDARRAY_P(object); if (intern->fptr_offset_set) { - zval tmp; if (!offset) { ZVAL_NULL(&tmp); offset = &tmp; diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c index 8ff3427011..6a0049733f 100644 --- a/ext/spl/spl_iterators.c +++ b/ext/spl/spl_iterators.c @@ -1998,7 +1998,6 @@ SPL_METHOD(CallbackFilterIterator, accept) zend_fcall_info *fci = &intern->u.cbfilter->fci; zend_fcall_info_cache *fcc = &intern->u.cbfilter->fcc; zval params[3]; - zval result; if (zend_parse_parameters_none() == FAILURE) { return; @@ -2012,19 +2011,22 @@ SPL_METHOD(CallbackFilterIterator, accept) ZVAL_COPY_VALUE(¶ms[1], &intern->current.key); ZVAL_COPY_VALUE(¶ms[2], &intern->inner.zobject); - fci->retval = &result; + fci->retval = return_value; fci->param_count = 3; fci->params = params; fci->no_separation = 0; - if (zend_call_function(fci, fcc) != SUCCESS || Z_TYPE(result) == IS_UNDEF) { + if (zend_call_function(fci, fcc) != SUCCESS || Z_ISUNDEF_P(return_value)) { RETURN_FALSE; } + if (EG(exception)) { - return; + RETURN_NULL(); } - RETURN_ZVAL(&result, 1, 1); + /* zend_call_function may change args to IS_REF */ + ZVAL_COPY_VALUE(&intern->current.data, ¶ms[0]); + ZVAL_COPY_VALUE(&intern->current.key, ¶ms[1]); } /* }}} */ diff --git a/ext/spl/tests/bug72051.phpt b/ext/spl/tests/bug72051.phpt new file mode 100644 index 0000000000..1dfc056d7e --- /dev/null +++ b/ext/spl/tests/bug72051.phpt @@ -0,0 +1,26 @@ +--TEST-- +Bug #72051 (The reference in CallbackFilterIterator doesn't work as expected) +--FILE-- +<?php + +$data = [ + [1,2] +]; + +$callbackTest = new CallbackFilterIterator(new ArrayIterator($data), function (&$current) { + $current['message'] = 'Test message'; + return true; +}); + +$callbackTest->rewind(); +$data = $callbackTest->current(); +$callbackTest->next(); +print_r($data); +?> +--EXPECT-- +Array +( + [0] => 1 + [1] => 2 + [message] => Test message +) diff --git a/ext/sqlite3/sqlite3.c b/ext/sqlite3/sqlite3.c index 3c7239021f..d7f7722959 100644 --- a/ext/sqlite3/sqlite3.c +++ b/ext/sqlite3/sqlite3.c @@ -683,7 +683,6 @@ static int sqlite3_do_callback(struct php_sqlite3_fci *fc, zval *cb, int argc, s fake_argc = argc + is_agg; fc->fci.size = sizeof(fc->fci); - fc->fci.function_table = EG(function_table); ZVAL_COPY_VALUE(&fc->fci.function_name, cb); fc->fci.object = NULL; fc->fci.retval = &retval; @@ -841,7 +840,6 @@ static int php_sqlite3_callback_compare(void *coll, int a_len, const void *a, in int ret; collation->fci.fci.size = (sizeof(collation->fci.fci)); - collation->fci.fci.function_table = EG(function_table); ZVAL_COPY_VALUE(&collation->fci.fci.function_name, &collation->cmp_func); collation->fci.fci.object = NULL; collation->fci.fci.retval = &retval; @@ -1392,6 +1390,26 @@ static int register_bound_parameter_to_sqlite(struct php_sqlite3_bound_param *pa } /* }}} */ +/* {{{ Best try to map between PHP and SQLite. Default is still text. */ +#define PHP_SQLITE3_SET_TYPE(z, p) \ + switch (Z_TYPE_P(z)) { \ + default: \ + (p).type = SQLITE_TEXT; \ + break; \ + case IS_LONG: \ + case IS_TRUE: \ + case IS_FALSE: \ + (p).type = SQLITE_INTEGER; \ + break; \ + case IS_DOUBLE: \ + (p).type = SQLITE_FLOAT; \ + break; \ + case IS_NULL: \ + (p).type = SQLITE_NULL; \ + break; \ + } +/* }}} */ + /* {{{ proto bool SQLite3Stmt::bindParam(int parameter_number, mixed parameter [, int type]) Bind Parameter to a stmt variable. */ PHP_METHOD(sqlite3stmt, bindParam) @@ -1416,6 +1434,10 @@ PHP_METHOD(sqlite3stmt, bindParam) ZVAL_COPY(¶m.parameter, parameter); + if (ZEND_NUM_ARGS() < 3) { + PHP_SQLITE3_SET_TYPE(parameter, param); + } + if (!register_bound_parameter_to_sqlite(¶m, stmt_obj)) { if (!Z_ISUNDEF(param.parameter)) { zval_ptr_dtor(&(param.parameter)); @@ -1451,6 +1473,10 @@ PHP_METHOD(sqlite3stmt, bindValue) ZVAL_COPY(¶m.parameter, parameter); + if (ZEND_NUM_ARGS() < 3) { + PHP_SQLITE3_SET_TYPE(parameter, param); + } + if (!register_bound_parameter_to_sqlite(¶m, stmt_obj)) { if (!Z_ISUNDEF(param.parameter)) { zval_ptr_dtor(&(param.parameter)); @@ -1462,6 +1488,8 @@ PHP_METHOD(sqlite3stmt, bindValue) } /* }}} */ +#undef PHP_SQLITE3_SET_TYPE + /* {{{ proto SQLite3Result SQLite3Stmt::execute() Executes a prepared statement and returns a result set object. */ PHP_METHOD(sqlite3stmt, execute) diff --git a/ext/sqlite3/tests/sqlite3_bind_bug68849.phpt b/ext/sqlite3/tests/sqlite3_bind_bug68849.phpt new file mode 100644 index 0000000000..321f883a8e --- /dev/null +++ b/ext/sqlite3/tests/sqlite3_bind_bug68849.phpt @@ -0,0 +1,71 @@ +--TEST-- +Bug #68849 bindValue is not using the right data type +--SKIPIF-- +<?php require_once(dirname(__FILE__) . '/skipif.inc'); ?> +--FILE-- +<?php + +$db = new SQLite3(':memory:'); + +$db->exec("CREATE TABLE test (a INTEGER, b TEXT, c REAL);" . + "INSERT INTO test VALUES (1, 'hello', 3.14);" . + "INSERT INTO test VALUES (3, 'world', 3.15);" . + "INSERT INTO test VALUES (0, '42', 0.42);" +); + +$s = $db->prepare('SELECT * FROM test WHERE (a+2) = ?;'); +$s->bindValue(1, 3); +$r = $s->execute(); +var_dump($r->fetchArray(SQLITE3_ASSOC)); + +$s = $db->prepare('SELECT * FROM test WHERE a = ?;'); +$s->bindValue(1, true); +$r = $s->execute(); +var_dump($r->fetchArray(SQLITE3_ASSOC)); + +$s = $db->prepare('SELECT * FROM test WHERE a = ?;'); +$s->bindValue(1, false); +$r = $s->execute(); +var_dump($r->fetchArray(SQLITE3_ASSOC)); + +$s = $db->prepare('SELECT * FROM test WHERE c = ?;'); +$s->bindValue(1, 3.15); +$r = $s->execute(); +var_dump($r->fetchArray(SQLITE3_ASSOC)); + +?> +==DONE== +--EXPECTF-- +array(3) { + ["a"]=> + int(1) + ["b"]=> + string(5) "hello" + ["c"]=> + float(3.14) +} +array(3) { + ["a"]=> + int(1) + ["b"]=> + string(5) "hello" + ["c"]=> + float(3.14) +} +array(3) { + ["a"]=> + int(0) + ["b"]=> + string(2) "42" + ["c"]=> + float(0.42) +} +array(3) { + ["a"]=> + int(3) + ["b"]=> + string(5) "world" + ["c"]=> + float(3.15) +} +==DONE== diff --git a/ext/standard/array.c b/ext/standard/array.c index c9a82390a4..a2cc00dc30 100644 --- a/ext/standard/array.c +++ b/ext/standard/array.c @@ -1843,8 +1843,11 @@ PHP_FUNCTION(extract) if (var_exists && ZSTR_LEN(var_name) == sizeof("GLOBALS")-1 && !strcmp(ZSTR_VAL(var_name), "GLOBALS")) { break; } - if (var_exists && ZSTR_LEN(var_name) == sizeof("this")-1 && !strcmp(ZSTR_VAL(var_name), "this") && EG(scope) && ZSTR_LEN(EG(scope)->name) != 0) { - break; + if (var_exists && ZSTR_LEN(var_name) == sizeof("this")-1 && !strcmp(ZSTR_VAL(var_name), "this")) { + zend_class_entry *scope = zend_get_executed_scope(); + if (scope && ZSTR_LEN(scope->name) != 0) { + break; + } } ZVAL_STR_COPY(&final_name, var_name); break; @@ -2023,6 +2026,7 @@ PHP_FUNCTION(array_fill) Z_ARRVAL_P(return_value)->nNumUsed = start_key + num; Z_ARRVAL_P(return_value)->nNumOfElements = num; Z_ARRVAL_P(return_value)->nInternalPointer = start_key; + Z_ARRVAL_P(return_value)->nNextFreeElement = start_key + num; if (Z_REFCOUNTED_P(val)) { GC_REFCOUNT(Z_COUNTED_P(val)) += num; @@ -3515,15 +3519,20 @@ static inline zval *array_column_fetch_prop(zval *data, zval *name, zval *rv) zval *prop = NULL; if (Z_TYPE_P(data) == IS_OBJECT) { - zend_string *key = zval_get_string(name); + if (!Z_OBJ_HANDLER_P(data, has_property) || !Z_OBJ_HANDLER_P(data, read_property)) { + return NULL; + } - if (!Z_OBJ_HANDLER_P(data, has_property) || Z_OBJ_HANDLER_P(data, has_property)(data, name, 1, NULL)) { - prop = zend_read_property(Z_OBJCE_P(data), data, ZSTR_VAL(key), ZSTR_LEN(key), 1, rv); + /* The has_property check is first performed in "exists" mode (which returns true for + * properties that are null but exist) and then in "has" mode to handle objects that + * implement __isset (which is not called in "exists" mode). */ + if (Z_OBJ_HANDLER_P(data, has_property)(data, name, 2, NULL) + || Z_OBJ_HANDLER_P(data, has_property)(data, name, 0, NULL)) { + prop = Z_OBJ_HANDLER_P(data, read_property)(data, name, BP_VAR_R, NULL, rv); } - zend_string_release(key); } else if (Z_TYPE_P(data) == IS_ARRAY) { if (Z_TYPE_P(name) == IS_STRING) { - prop = zend_hash_find(Z_ARRVAL_P(data), Z_STR_P(name)); + prop = zend_symtable_find(Z_ARRVAL_P(data), Z_STR_P(name)); } else if (Z_TYPE_P(name) == IS_LONG) { prop = zend_hash_index_find(Z_ARRVAL_P(data), Z_LVAL_P(name)); } diff --git a/ext/standard/assert.c b/ext/standard/assert.c index 109ba3ba22..2cb6285f4e 100644 --- a/ext/standard/assert.c +++ b/ext/standard/assert.c @@ -164,7 +164,6 @@ PHP_FUNCTION(assert) if (Z_TYPE_P(assertion) == IS_STRING) { zval retval; int old_error_reporting = 0; /* shut up gcc! */ - zend_class_entry *orig_scope = EG(scope); myeval = Z_STRVAL_P(assertion); @@ -194,8 +193,6 @@ PHP_FUNCTION(assert) EG(error_reporting) = old_error_reporting; } - EG(scope) = orig_scope; - convert_to_boolean(&retval); val = Z_TYPE(retval) == IS_TRUE; } else { diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c index 6323d18b5f..f887903f26 100644 --- a/ext/standard/basic_functions.c +++ b/ext/standard/basic_functions.c @@ -3834,20 +3834,21 @@ PHP_FUNCTION(constant) { zend_string *const_name; zval *c; + zend_class_entry *scope; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &const_name) == FAILURE) { return; } - c = zend_get_constant_ex(const_name, NULL, ZEND_FETCH_CLASS_SILENT); + scope = zend_get_executed_scope(); + c = zend_get_constant_ex(const_name, scope, ZEND_FETCH_CLASS_SILENT); if (c) { - ZVAL_COPY_VALUE(return_value, c); + ZVAL_DUP(return_value, c); if (Z_CONSTANT_P(return_value)) { - if (UNEXPECTED(zval_update_constant_ex(return_value, 1, NULL) != SUCCESS)) { + if (UNEXPECTED(zval_update_constant_ex(return_value, scope) != SUCCESS)) { return; } } - zval_copy_ctor(return_value); } else { php_error_docref(NULL, E_WARNING, "Couldn't find constant %s", ZSTR_VAL(const_name)); RETURN_NULL(); diff --git a/ext/standard/file.c b/ext/standard/file.c index 535fc44f3f..eef1287b0f 100644 --- a/ext/standard/file.c +++ b/ext/standard/file.c @@ -262,19 +262,19 @@ PHP_MINIT_FUNCTION(file) REGISTER_LONG_CONSTANT("STREAM_IPPROTO_IP", IPPROTO_IP, CONST_CS|CONST_PERSISTENT); #endif -#ifdef IPPROTO_TCP +#if defined(IPPROTO_TCP) || defined(PHP_WIN32) REGISTER_LONG_CONSTANT("STREAM_IPPROTO_TCP", IPPROTO_TCP, CONST_CS|CONST_PERSISTENT); #endif -#ifdef IPPROTO_UDP +#if defined(IPPROTO_UDP) || defined(PHP_WIN32) REGISTER_LONG_CONSTANT("STREAM_IPPROTO_UDP", IPPROTO_UDP, CONST_CS|CONST_PERSISTENT); #endif -#ifdef IPPROTO_ICMP +#if defined(IPPROTO_ICMP) || defined(PHP_WIN32) REGISTER_LONG_CONSTANT("STREAM_IPPROTO_ICMP", IPPROTO_ICMP, CONST_CS|CONST_PERSISTENT); #endif -#ifdef IPPROTO_RAW +#if defined(IPPROTO_RAW) || defined(PHP_WIN32) REGISTER_LONG_CONSTANT("STREAM_IPPROTO_RAW", IPPROTO_RAW, CONST_CS|CONST_PERSISTENT); #endif diff --git a/ext/standard/streamsfuncs.c b/ext/standard/streamsfuncs.c index def1fb88d7..0e5d0ce79e 100644 --- a/ext/standard/streamsfuncs.c +++ b/ext/standard/streamsfuncs.c @@ -613,6 +613,7 @@ static int stream_array_to_fd_set(zval *stream_array, fd_set *fds, php_socket_t the higher bits of a SOCKET variable uninitialized on systems with little endian. */ php_socket_t this_fd; + ZVAL_DEREF(elem); php_stream_from_zval_no_verify(stream, elem); if (stream == NULL) { continue; @@ -652,6 +653,7 @@ static int stream_array_from_fd_set(zval *stream_array, fd_set *fds) ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(stream_array), num_ind, key, elem) { php_socket_t this_fd; + ZVAL_DEREF(elem); php_stream_from_zval_no_verify(stream, elem); if (stream == NULL) { continue; @@ -698,6 +700,7 @@ static int stream_array_emulate_read_fd_set(zval *stream_array) zend_hash_init(Z_ARRVAL(new_array), zend_hash_num_elements(Z_ARRVAL_P(stream_array)), NULL, ZVAL_PTR_DTOR, 0); ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(stream_array), elem) { + ZVAL_DEREF(elem); php_stream_from_zval_no_verify(stream, elem); if (stream == NULL) { continue; diff --git a/ext/standard/string.c b/ext/standard/string.c index ab793b6217..b2fcfa0ec3 100644 --- a/ext/standard/string.c +++ b/ext/standard/string.c @@ -1229,16 +1229,16 @@ PHPAPI void php_implode(const zend_string *delim, zval *arr, zval *return_value) ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(arr), tmp) { if (Z_TYPE_P(tmp) == IS_LONG) { - double val = Z_LVAL_P(tmp); + zend_long val = Z_LVAL_P(tmp); + *++strptr = NULL; ((zend_long *) (strings + numelems))[strptr - strings] = Z_LVAL_P(tmp); - if (val < 0) { - val = -10 * val; + if (val <= 0) { + len++; } - if (val < 10) { + while (val) { + val /= 10; len++; - } else { - len += (int) log10(10 * (double) val); } } else { *++strptr = zval_get_string(tmp); @@ -5375,7 +5375,7 @@ PHP_FUNCTION(str_pad) return; } - result = zend_string_safe_alloc(ZSTR_LEN(input), 1, num_pad_chars, 0); + result = zend_string_safe_alloc(1, ZSTR_LEN(input), num_pad_chars, 0); ZSTR_LEN(result) = 0; /* We need to figure out the left/right padding lengths. */ diff --git a/ext/standard/tests/array/array_column_numeric_string_key.phpt b/ext/standard/tests/array/array_column_numeric_string_key.phpt new file mode 100644 index 0000000000..aed3c35ea2 --- /dev/null +++ b/ext/standard/tests/array/array_column_numeric_string_key.phpt @@ -0,0 +1,23 @@ +--TEST-- +array_column() treats numeric string keys as usual +--FILE-- +<?php + +$array = [[42 => 'a'], [42 => 'b']]; +var_dump(array_column($array, 42)); +var_dump(array_column($array, "42")); + +?> +--EXPECT-- +array(2) { + [0]=> + string(1) "a" + [1]=> + string(1) "b" +} +array(2) { + [0]=> + string(1) "a" + [1]=> + string(1) "b" +} diff --git a/ext/standard/tests/array/array_column_property_visibility.phpt b/ext/standard/tests/array/array_column_property_visibility.phpt new file mode 100644 index 0000000000..4639a3c9c5 --- /dev/null +++ b/ext/standard/tests/array/array_column_property_visibility.phpt @@ -0,0 +1,27 @@ +--TEST-- +array_column() respects property visibility +--FILE-- +<?php + +class Test { + private $prop; + public function __construct($value) { + $this->prop = $value; + } + public function __isset($name) { + return true; + } + public function __get($name) { + return "__get($this->prop)"; + } +} + +$arr = [new Test("foobar")]; +var_dump(array_column($arr, "prop")); + +?> +--EXPECT-- +array(1) { + [0]=> + string(13) "__get(foobar)" +} diff --git a/ext/standard/tests/array/bug72031.phpt b/ext/standard/tests/array/bug72031.phpt new file mode 100644 index 0000000000..541fd3c4ec --- /dev/null +++ b/ext/standard/tests/array/bug72031.phpt @@ -0,0 +1,48 @@ +--TEST-- +Bug #72031: array_column() against an array of objects discards all values matching null +--FILE-- +<?php + +class myObj { + public $prop; + public function __construct($prop) { + $this->prop = $prop; + } +} + +$objects = [ + new myObj(-1), + new myObj(0), + new myObj(1), + new myObj(2), + new myObj(null), + new myObj(true), + new myObj(false), + new myObj('abc'), + new myObj(''), +]; + +var_dump(array_column($objects, 'prop')); + +?> +--EXPECT-- +array(9) { + [0]=> + int(-1) + [1]=> + int(0) + [2]=> + int(1) + [3]=> + int(2) + [4]=> + NULL + [5]=> + bool(true) + [6]=> + bool(false) + [7]=> + string(3) "abc" + [8]=> + string(0) "" +} diff --git a/ext/standard/tests/array/bug72116.phpt b/ext/standard/tests/array/bug72116.phpt new file mode 100644 index 0000000000..7951f69130 --- /dev/null +++ b/ext/standard/tests/array/bug72116.phpt @@ -0,0 +1,18 @@ +--TEST-- +Bug #72116 (insertion after array_fill fails) +--FILE-- +<?php + +$x = array_fill(0, 1, '..'); +$x[] = 'a'; +var_dump($x); + +?> +--EXPECT-- +array(2) { + [0]=> + string(2) ".." + [1]=> + string(1) "a" +} + diff --git a/ext/standard/tests/file/bug72035.phpt b/ext/standard/tests/file/bug72035.phpt new file mode 100644 index 0000000000..a2abbb7f35 --- /dev/null +++ b/ext/standard/tests/file/bug72035.phpt @@ -0,0 +1,40 @@ +--TEST-- +Bug #72035 php-cgi.exe fails to run scripts relative to drive root +--SKIPIF-- +<?php +if(substr(PHP_OS, 0, 3) != 'WIN' ) die('skip windows only test'); +if(php_sapi_name() != "cli") die('skip CLI only test'); + +$cgi = realpath(dirname(PHP_BINARY)) . DIRECTORY_SEPARATOR . "php-cgi.exe"; +if (!file_exists($cgi)) die('skip CGI binary not found'); +?> +--FILE-- +<?php + +$fl = dirname(__FILE__) . DIRECTORY_SEPARATOR . md5(uniqid()) . ".php"; +$fl = substr($fl, 2); + +$cgi = realpath(dirname(PHP_BINARY) . DIRECTORY_SEPARATOR . "php-cgi.exe"); + +file_put_contents($fl, "<?php echo \"hello\", \"\n\"; ?>"); + +$cmd = "$cgi -n -C $fl"; + +/* Need to run CGI with the env reset. */ +$desc = array(0 => array("pipe", "r")); +$proc = proc_open($cmd, $desc, $pipes, getcwd(), array()); +if (is_resource($proc)) { + echo stream_get_contents($pipes[0]); + + proc_close($proc); +} + +unlink($fl); +?> +==DONE== +--EXPECTF-- +X-Powered-By: PHP/%s +Content-type: text/html; charset=UTF-8 + +hello +==DONE== diff --git a/ext/standard/tests/file/file_put_contents_variation7-win32.phpt b/ext/standard/tests/file/file_put_contents_variation7-win32.phpt index d7bfdf9233..e1a94a2043 100644 --- a/ext/standard/tests/file/file_put_contents_variation7-win32.phpt +++ b/ext/standard/tests/file/file_put_contents_variation7-win32.phpt @@ -59,10 +59,10 @@ for($i = 0; $i<count($allDirs); $i++) { $j = $i+1; $dir = $allDirs[$i]; echo "\n-- Iteration $j --\n"; - $res = file_put_contents($dir."\\".$filename, ($data + $i)); + $res = file_put_contents($dir."\\".$filename, ($data . $i)); if ($res !== false) { $in = file_get_contents($absFile); - if ($in == ($data + $i)) { + if ($in == ($data . $i)) { echo "Data written correctly\n"; } else { @@ -127,4 +127,4 @@ No data written -- Iteration 12 -- Data written correctly -*** Done ***
\ No newline at end of file +*** Done *** diff --git a/ext/standard/tests/file/fscanf.phpt b/ext/standard/tests/file/fscanf.phpt index c37bdeb20a..003dd53dfa 100644 --- a/ext/standard/tests/file/fscanf.phpt +++ b/ext/standard/tests/file/fscanf.phpt @@ -7,7 +7,7 @@ $filename = dirname(__FILE__)."/fscanf.dat"; var_dump(fscanf()); var_dump(fscanf(array())); -var_dump(fscanf(array(), array(), new stdclass)); +var_dump(fscanf(array(), array())); file_put_contents($filename, "data"); diff --git a/ext/standard/tests/streams/bug72075.phpt b/ext/standard/tests/streams/bug72075.phpt new file mode 100644 index 0000000000..93dce60350 --- /dev/null +++ b/ext/standard/tests/streams/bug72075.phpt @@ -0,0 +1,15 @@ +--TEST-- +Bug #72075 (Referencing socket resources breaks stream_select) +--FILE-- +<?php +$r = [stream_socket_server("tcp://127.0.0.1:0", $errno, $errStr)]; +$w = NULL; +$e = NULL; + +// Without this line, all is well: +$dummy =& $r[0]; + +print stream_select($r, $w, $e, 0.5); + +--EXPECT-- +0 diff --git a/ext/standard/tests/streams/stream_context_tcp_nodelay.phpt b/ext/standard/tests/streams/stream_context_tcp_nodelay.phpt new file mode 100644 index 0000000000..ca3289fbc2 --- /dev/null +++ b/ext/standard/tests/streams/stream_context_tcp_nodelay.phpt @@ -0,0 +1,22 @@ +--TEST-- +stream context tcp_nodelay +--SKIPIF-- +<?php if (!extension_loaded("sockets")) die("skip: need sockets") ?> +--FILE-- +<?php +$ctxt = stream_context_create([ + "socket" => [ + "tcp_nodelay" => true + ] +]); + +$stream = stream_socket_client( + "tcp://www.php.net:80", $errno, $errstr, 10, STREAM_CLIENT_CONNECT, $ctxt); + +$socket = + socket_import_stream($stream); + +var_dump(socket_get_option($socket, SOL_TCP, TCP_NODELAY) > 0); +?> +--EXPECT-- +bool(true) diff --git a/ext/standard/tests/streams/stream_context_tcp_nodelay_fopen.phpt b/ext/standard/tests/streams/stream_context_tcp_nodelay_fopen.phpt new file mode 100644 index 0000000000..08ad4c2d2e --- /dev/null +++ b/ext/standard/tests/streams/stream_context_tcp_nodelay_fopen.phpt @@ -0,0 +1,21 @@ +--TEST-- +stream context tcp_nodelay fopen +--SKIPIF-- +<?php if (!extension_loaded("sockets")) die("skip: need sockets") ?> +--FILE-- +<?php +$ctxt = stream_context_create([ + "socket" => [ + "tcp_nodelay" => true + ] +]); + +$stream = fopen("http://www.php.net", "r", false, $ctxt); + +$socket = + @socket_import_stream($stream); + +var_dump(socket_get_option($socket, STREAM_IPPROTO_TCP, TCP_NODELAY) > 0); +?> +--EXPECT-- +bool(true) diff --git a/ext/standard/tests/streams/stream_context_tcp_nodelay_server.phpt b/ext/standard/tests/streams/stream_context_tcp_nodelay_server.phpt new file mode 100644 index 0000000000..6606a15052 --- /dev/null +++ b/ext/standard/tests/streams/stream_context_tcp_nodelay_server.phpt @@ -0,0 +1,47 @@ +--TEST-- +stream context tcp_nodelay server +--SKIPIF-- +<?php if (!extension_loaded("sockets")) die("skip: need sockets") ?> +--FILE-- +<?php +$serverCode = <<<'CODE' + $ctxt = stream_context_create([ + "socket" => [ + "tcp_nodelay" => true + ] + ]); + + $server = stream_socket_server( + "tcp://127.0.0.1:9099", $errno, $errstr, STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $ctxt); + + $client = stream_socket_accept($server); + + var_dump(socket_get_option( + socket_import_stream($server), + SOL_TCP, TCP_NODELAY) > 0); + + var_dump(socket_get_option( + socket_import_stream($client), + SOL_TCP, TCP_NODELAY) > 0); + + fclose($client); + fclose($server); +CODE; + +$clientCode = <<<'CODE' + $test = stream_socket_client( + "tcp://127.0.0.1:9099", $errno, $errstr, 10); + + sleep(1); + + fclose($test); +CODE; + +include sprintf( + "%s/../../../openssl/tests/ServerClientTestCase.inc", + dirname(__FILE__)); +ServerClientTestCase::getInstance()->run($serverCode, $clientCode); +?> +--EXPECT-- +bool(false) +bool(true) diff --git a/ext/standard/tests/strings/bug72100.phpt b/ext/standard/tests/strings/bug72100.phpt new file mode 100644 index 0000000000..7fcc0831b6 --- /dev/null +++ b/ext/standard/tests/strings/bug72100.phpt @@ -0,0 +1,18 @@ +--TEST-- +Test implode() function, problems with big numbers +--SKIPIF-- +<?php +if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platform only"); +?> +--FILE-- +<?php +var_dump( implode(" ", ["hello long", 999999999999999999, PHP_INT_MAX])); +var_dump( implode(" ", ["hello negative long", -999999999999999999, PHP_INT_MIN] ) ); +var_dump( implode(" ", ["hello small long", -101, -100, -99, -90, -11, -10, -9, -1, 0, 1, 2, 9, 10, 11, 90, 99, 100, 101] ) ); +echo "Done\n"; +?> +--EXPECT-- +string(49) "hello long 999999999999999999 9223372036854775807" +string(60) "hello negative long -999999999999999999 -9223372036854775808" +string(76) "hello small long -101 -100 -99 -90 -11 -10 -9 -1 0 1 2 9 10 11 90 99 100 101" +Done diff --git a/ext/standard/var.c b/ext/standard/var.c index acb1d40c01..76d92a5fd3 100644 --- a/ext/standard/var.c +++ b/ext/standard/var.c @@ -1080,6 +1080,11 @@ PHP_FUNCTION(unserialize) in case nesting calls to unserialize */ var_push_dtor(&var_hash, return_value); + /* Ensure return value is a value */ + if (Z_ISREF_P(return_value)) { + zend_unwrap_reference(return_value); + } + PHP_VAR_UNSERIALIZE_DESTROY(var_hash); if (class_hash) { zend_hash_destroy(class_hash); diff --git a/ext/standard/var_unserializer.c b/ext/standard/var_unserializer.c index 389c42b3de..3fc074dd6a 100644 --- a/ext/standard/var_unserializer.c +++ b/ext/standard/var_unserializer.c @@ -171,7 +171,7 @@ PHPAPI void var_destroy(php_unserialize_data_t *var_hashx) static zend_string *unserialize_str(const unsigned char **p, size_t len, size_t maxlen) { size_t i, j; - zend_string *str = zend_string_alloc(len, 0); + zend_string *str = zend_string_safe_alloc(1, len, 0, 0); unsigned char *end = *(unsigned char **)p+maxlen; if (end < *p) { diff --git a/ext/standard/var_unserializer.re b/ext/standard/var_unserializer.re index c7e0581630..81cc26db9d 100644 --- a/ext/standard/var_unserializer.re +++ b/ext/standard/var_unserializer.re @@ -169,7 +169,7 @@ PHPAPI void var_destroy(php_unserialize_data_t *var_hashx) static zend_string *unserialize_str(const unsigned char **p, size_t len, size_t maxlen) { size_t i, j; - zend_string *str = zend_string_alloc(len, 0); + zend_string *str = zend_string_safe_alloc(1, len, 0, 0); unsigned char *end = *(unsigned char **)p+maxlen; if (end < *p) { diff --git a/ext/wddx/wddx.c b/ext/wddx/wddx.c index 330cb49f08..e848afdeb7 100644 --- a/ext/wddx/wddx.c +++ b/ext/wddx/wddx.c @@ -954,12 +954,8 @@ static void php_wddx_pop_element(void *user_data, const XML_Char *name) /* Clean up class name var entry */ zval_ptr_dtor(&ent1->data); } else if (Z_TYPE(ent2->data) == IS_OBJECT) { - zend_class_entry *old_scope = EG(scope); - - EG(scope) = Z_OBJCE(ent2->data); - add_property_zval(&ent2->data, ent1->varname, &ent1->data); + zend_update_property(Z_OBJCE(ent2->data), &ent2->data, ent1->varname, strlen(ent1->varname), &ent1->data); if Z_REFCOUNTED(ent1->data) Z_DELREF(ent1->data); - EG(scope) = old_scope; } else { zend_symtable_str_update(target_hash, ent1->varname, strlen(ent1->varname), &ent1->data); } diff --git a/ext/xml/tests/bug72099.phpt b/ext/xml/tests/bug72099.phpt new file mode 100644 index 0000000000..50173a6a4c --- /dev/null +++ b/ext/xml/tests/bug72099.phpt @@ -0,0 +1,17 @@ +--TEST-- +Bug #72099: xml_parse_into_struct segmentation fault +--SKIPIF-- +<?php +require_once("skipif.inc"); +?> +--FILE-- +<?php +$var1=xml_parser_create_ns(); +$var2=str_repeat("a", 10); +$var3=[]; +$var4=[]; +xml_parse_into_struct($var1, $var2, $var3, $var4); +var_dump($var3); +--EXPECT-- +array(0) { +}
\ No newline at end of file diff --git a/ext/xml/xml.c b/ext/xml/xml.c index a3a42655d0..6b93e2fcc3 100644 --- a/ext/xml/xml.c +++ b/ext/xml/xml.c @@ -483,7 +483,6 @@ static void xml_call_handler(xml_parser *parser, zval *handler, zend_function *f zend_fcall_info fci; fci.size = sizeof(fci); - fci.function_table = EG(function_table); ZVAL_COPY_VALUE(&fci.function_name, handler); fci.object = Z_OBJ(parser->object); fci.retval = retval; diff --git a/ext/xmlreader/tests/XMLReaderBad_bug71805.xml b/ext/xmlreader/tests/XMLReaderBad_bug71805.xml new file mode 100644 index 0000000000..68ee25ddb8 --- /dev/null +++ b/ext/xmlreader/tests/XMLReaderBad_bug71805.xml @@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="utf-8"?> +<records> + +<record><aaa><bbbb><ccc><![CDATA[XXX Xxxxxxxxxxxx]]></ccc><ddd><![CDATA[XXX Xx]]></ddd></bbbb><eee><![CDATA[Xxxxx xxxxxxx: xxxx://xxx.xxx.xx.xx/xxxx?xxxxXx=0xx000x0-000x-0xx0-x000-x0000xx0xx00 +Xxxxxxxxxxxx xx Xxxxxxxxxxxx Xxxxxxxxx xx Xxxxxxxxx Xxxxxxxxxxxx Xxxxxxxxxxx Xxxxxxxxxxxx (XXX Xxxxxxxxxxxx), xxxxxxxxx xxxxxxx xx Xxx Xxxxxxxxxx Xxxxxxxxxx Xxx.]]></eee></aaa><fff><bbbb><ggg><![CDATA[Xxxxxxxxx Xxxxxxxxxxxxxxx Xxxxxxxxxx xx Xxxxxxxxxxxx]]></ggg><ccc><![CDATA[XXX Xxxxxxxxxxxx]]></ccc></bbbb><hhh><![CDATA[Xx xxxxx, xx xxxxxxxxxxx XXX Xxxxxxxxxxxx x xxxxxcé x’xxxxxxxx xxx x’Xxxxxxléx léxxxxxxxxx xx xx xxxxxxxx xx xx Xxxxxxxxxx Xxxxxxxxxx Xxx (xxx xxx xx xxxxxxxxxx xxxxxxxxx). Xxxxx xxx xréxxxx xxx xxxxxx xxx déxxxxxxxx XXX Xxxxxxxxxxxx xx xxxx xx’xxxxxxxxxxxx xxxxxxxxxxxxxxx xxxxréxxxxxxtéx xx xxxxxxx xxx XX, xxx XXX xx xxx XXX xx xx xxxxxxxx xx xxxxx x’xxxxxxxx xx xxxxx xx xxxxxxxxx xxxxxxxxxxxxx xxréé (XXX). (Xxxxxxxxéx XXX - Xxx 0000)]]></hhh></fff></record> + +</records>
\ No newline at end of file diff --git a/ext/xmlreader/tests/XMLReaderGood_bug71805.xml b/ext/xmlreader/tests/XMLReaderGood_bug71805.xml new file mode 100644 index 0000000000..9a59e0c978 --- /dev/null +++ b/ext/xmlreader/tests/XMLReaderGood_bug71805.xml @@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="utf-8"?> +<records> + +<record><aaa><bbbb><ddd><![CDATA[XXX Xx]]></ddd></bbbb><eee><![CDATA[Xxxxx xxxxxxx: xxxx://xxx.xxx.xx.xx/xxxx?xxxxXx=0xx000x0-000x-0xx0-x000-x0000xx0xx00 +Xxxxxxxxxxxx xx Xxxxxxxxxxxx Xxxxxxxxx xx Xxxxxxxxx Xxxxxxxxxxxx Xxxxxxxxxxx Xxxxxxxxxxxx (XXX Xxxxxxxxxxxx), xxxxxxxxx xxxxxxx xx Xxx Xxxxxxxxxx Xxxxxxxxxx Xxx.]]></eee></aaa><fff><bbbb><ggg><![CDATA[Xxxxxxxxx Xxxxxxxxxxxxxxx Xxxxxxxxxx xx Xxxxxxxxxxxx]]></ggg><ccc><![CDATA[XXX Xxxxxxxxxxxx]]></ccc></bbbb><hhh><![CDATA[Xx xxxxx, xx xxxxxxxxxxx XXX Xxxxxxxxxxxx x xxxxxcé x’xxxxxxxx xxx x’Xxxxxxléx léxxxxxxxxx xx xx xxxxxxxx xx xx Xxxxxxxxxx Xxxxxxxxxx Xxx (xxx xxx xx xxxxxxxxxx xxxxxxxxx). Xxxxx xxx xréxxxx xxx xxxxxx xxx déxxxxxxxx XXX Xxxxxxxxxxxx xx xxxx xx’xxxxxxxxxxxx xxxxxxxxxxxxxxx xxxxréxxxxxxtéx xx xxxxxxx xxx XX, xxx XXX xx xxx XXX xx xx xxxxxxxx xx xxxxx x’xxxxxxxx xx xxxxx xx xxxxxxxxx xxxxxxxxxxxxx xxréé (XXX). (Xxxxxxxxéx XXX - Xxx 0000)]]></hhh></fff></record> + +</records>
\ No newline at end of file diff --git a/ext/xmlreader/tests/bug71805.phpt b/ext/xmlreader/tests/bug71805.phpt new file mode 100644 index 0000000000..3d1713ace5 --- /dev/null +++ b/ext/xmlreader/tests/bug71805.phpt @@ -0,0 +1,39 @@ +--TEST-- +XMLReader: Bug #71805 XML files can generate UTF-8 error even if they are UTF-8 +--SKIPIF-- +<?php if (!extension_loaded("xmlreader")) print "skip"; ?> +--FILE-- +<?php + +TestXML(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'XMLReaderGood_bug71805.xml'); +TestXML(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'XMLReaderBad_bug71805.xml'); + +function TestXML($file) { + $XR = new XMLReader; + $XR->open($file, null, LIBXML_NOBLANKS); + + while (($lastRead = $XR->read()) && ($XR->name !== 'records')); + while (($lastRead = $XR->read()) && ($XR->name !== 'record')); + while ($lastRead) { + $xml = $XR->readOuterXML(); + if ($xml === '') { + $err = ''; + if ($e = libxml_get_last_error()) { $err = $e->message.' (line: '.$e->line.')'; } + $XR->close(); + echo $file.' : Problem with file'.($err ? ' — '.$err : '').'.'; + echo "\n"; + return; + } + while (($lastRead = $XR->next()) && ($XR->name !== 'record')); + } + $XR->close(); + echo $file.' : Good!'; + echo "\n"; + return; +} +?> +===DONE=== +--EXPECTF-- +%sXMLReaderGood_bug71805.xml : Good! +%sXMLReaderBad_bug71805.xml : Good! +===DONE=== diff --git a/ext/xmlrpc/tests/bug70728.phpt b/ext/xmlrpc/tests/bug70728.phpt index 5510c33936..72f72f85b0 100644 --- a/ext/xmlrpc/tests/bug70728.phpt +++ b/ext/xmlrpc/tests/bug70728.phpt @@ -3,6 +3,7 @@ Bug #70728 (Type Confusion Vulnerability in PHP_to_XMLRPC_worker) --SKIPIF-- <?php if (!extension_loaded("xmlrpc")) print "skip"; +if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platform only"); ?> --FILE-- <?php @@ -26,5 +27,5 @@ object(stdClass)#1 (2) { ["xmlrpc_type"]=> string(6) "base64" ["scalar"]=> - int(73588229205) + float(73588229205) } diff --git a/ext/xmlrpc/tests/bug70728_64bit.phpt b/ext/xmlrpc/tests/bug70728_64bit.phpt new file mode 100644 index 0000000000..3ed5093918 --- /dev/null +++ b/ext/xmlrpc/tests/bug70728_64bit.phpt @@ -0,0 +1,31 @@ +--TEST-- +Bug #70728 (Type Confusion Vulnerability in PHP_to_XMLRPC_worker) +--SKIPIF-- +<?php +if (!extension_loaded("xmlrpc")) print "skip"; +if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platform only"); +?> +--FILE-- +<?php +$obj = new stdClass; +$obj->xmlrpc_type = 'base64'; +$obj->scalar = 0x1122334455; +var_dump(xmlrpc_encode($obj)); +var_dump($obj); +?> +--EXPECTF-- +string(135) "<?xml version="1.0" encoding="utf-8"?> +<params> +<param> + <value> + <base64>NzM1ODgyMjkyMDU= </base64> + </value> +</param> +</params> +" +object(stdClass)#1 (2) { + ["xmlrpc_type"]=> + string(6) "base64" + ["scalar"]=> + int(73588229205) +} diff --git a/ext/xsl/xsltprocessor.c b/ext/xsl/xsltprocessor.c index 1c434039e2..5339812253 100644 --- a/ext/xsl/xsltprocessor.c +++ b/ext/xsl/xsltprocessor.c @@ -295,7 +295,6 @@ static void xsl_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int t } fci.size = sizeof(fci); - fci.function_table = EG(function_table); if (fci.param_count > 0) { fci.params = args; } else { diff --git a/ext/zip/php_zip.c b/ext/zip/php_zip.c index db201af634..7c9adf4af7 100644 --- a/ext/zip/php_zip.c +++ b/ext/zip/php_zip.c @@ -1281,7 +1281,7 @@ static PHP_NAMED_FUNCTION(zif_zip_entry_read) } if (zr_rsrc->zf) { - buffer = zend_string_alloc(len, 0); + buffer = zend_string_safe_alloc(1, len, 0, 0); n = zip_fread(zr_rsrc->zf, ZSTR_VAL(buffer), ZSTR_LEN(buffer)); if (n > 0) { ZSTR_VAL(buffer)[n] = '\0'; @@ -2728,7 +2728,7 @@ static void php_zip_get_from(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */ RETURN_FALSE; } - buffer = zend_string_alloc(len, 0); + buffer = zend_string_safe_alloc(1, len, 0, 0); n = zip_fread(zf, ZSTR_VAL(buffer), ZSTR_LEN(buffer)); if (n < 1) { zend_string_free(buffer); diff --git a/main/fopen_wrappers.c b/main/fopen_wrappers.c index e4d5688de3..c3646ee0fd 100644 --- a/main/fopen_wrappers.c +++ b/main/fopen_wrappers.c @@ -505,6 +505,13 @@ PHPAPI zend_string *php_resolve_path(const char *filename, int filename_length, (IS_SLASH(filename[1]) || ((filename[1] == '.') && IS_SLASH(filename[2])))) || IS_ABSOLUTE_PATH(filename, filename_length) || +#if PHP_WIN32 + /* This should count as an absolute local path as well, however + IS_ABSOLUTE_PATH doesn't care about this path form till now. It + might be a big thing to extend, thus just a local handling for + now. */ + filename_length >=2 && IS_SLASH(filename[0]) && !IS_SLASH(filename[1]) || +#endif !path || !*path) { if (tsrm_realpath(filename, resolved_path)) { @@ -640,7 +647,7 @@ PHPAPI FILE *php_fopen_with_path(const char *filename, const char *mode, const c if ((*filename == '.') /* Absolute path open */ || IS_ABSOLUTE_PATH(filename, filename_length) - || (!path || (path && !*path)) + || (!path || !*path) ) { return php_fopen_and_set_opened_path(filename, mode, opened_path); } diff --git a/main/main.c b/main/main.c index fcb42b43b4..5762fce690 100644 --- a/main/main.c +++ b/main/main.c @@ -572,7 +572,7 @@ PHP_INI_BEGIN() STD_PHP_INI_ENTRY("user_ini.filename", ".user.ini", PHP_INI_SYSTEM, OnUpdateString, user_ini_filename, php_core_globals, core_globals) STD_PHP_INI_ENTRY("user_ini.cache_ttl", "300", PHP_INI_SYSTEM, OnUpdateLong, user_ini_cache_ttl, php_core_globals, core_globals) - STD_PHP_INI_BOOLEAN("exit_on_timeout", "0", PHP_INI_ALL, OnUpdateBool, exit_on_timeout, php_core_globals, core_globals) + STD_PHP_INI_ENTRY("hard_timeout", "2", PHP_INI_SYSTEM, OnUpdateLong, hard_timeout, zend_executor_globals, executor_globals) #ifdef PHP_WIN32 STD_PHP_INI_BOOLEAN("windows.show_crt_warning", "0", PHP_INI_ALL, OnUpdateBool, windows_show_crt_warning, php_core_globals, core_globals) #endif @@ -1505,8 +1505,6 @@ static ZEND_COLD void php_message_handler_for_zend(zend_long message, const void void php_on_timeout(int seconds) { PG(connection_status) |= PHP_CONNECTION_TIMEOUT; - zend_set_timeout(EG(timeout_seconds), 1); - if(PG(exit_on_timeout)) sapi_terminate_process(); } #if PHP_SIGCHILD diff --git a/main/network.c b/main/network.c index e7f1b84281..e53dc66a8a 100644 --- a/main/network.c +++ b/main/network.c @@ -487,6 +487,11 @@ php_socket_t php_network_bind_socket_to_local_addr(const char *host, unsigned po setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char*)&sockoptval, sizeof(sockoptval)); } #endif +#ifdef TCP_NODELAY + if (sockopts & STREAM_SOCKOP_TCP_NODELAY) { + setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&sockoptval, sizeof(sockoptval)); + } +#endif n = bind(sock, sa, socklen); @@ -726,7 +731,8 @@ PHPAPI php_socket_t php_network_accept_incoming(php_socket_t srvsock, socklen_t *addrlen, struct timeval *timeout, zend_string **error_string, - int *error_code + int *error_code, + int tcp_nodelay ) { php_socket_t clisock = -1; @@ -750,6 +756,11 @@ PHPAPI php_socket_t php_network_accept_incoming(php_socket_t srvsock, textaddr, addr, addrlen ); + if (tcp_nodelay) { +#ifdef TCP_NODELAY + setsockopt(clisock, IPPROTO_TCP, TCP_NODELAY, (char*)&tcp_nodelay, sizeof(tcp_nodelay)); +#endif + } } else { error = php_socket_errno(); } @@ -767,7 +778,6 @@ PHPAPI php_socket_t php_network_accept_incoming(php_socket_t srvsock, /* }}} */ - /* Connect to a remote host using an interruptible connect with optional timeout. * Optionally, the connect can be made asynchronously, which will implicitly * enable non-blocking mode on the socket. @@ -902,6 +912,15 @@ skip_bind: } } #endif + +#ifdef TCP_NODELAY + { + int val = 1; + if (sockopts & STREAM_SOCKOP_TCP_NODELAY) { + setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&val, sizeof(val)); + } + } +#endif n = php_network_connect_socket(sock, sa, socklen, asynchronous, timeout ? &working_timeout : NULL, error_string, error_code); diff --git a/main/php_globals.h b/main/php_globals.h index 057ec6679f..e50ea2ebfb 100644 --- a/main/php_globals.h +++ b/main/php_globals.h @@ -147,7 +147,6 @@ struct _php_core_globals { char *disable_functions; char *disable_classes; zend_bool allow_url_include; - zend_bool exit_on_timeout; #ifdef PHP_WIN32 zend_bool com_initialized; #endif diff --git a/main/php_network.h b/main/php_network.h index 4ddae5cd4c..2c342b4668 100644 --- a/main/php_network.h +++ b/main/php_network.h @@ -28,6 +28,7 @@ #else # undef closesocket # define closesocket close +# include <netinet/tcp.h> #endif #ifndef HAVE_SHUTDOWN @@ -115,6 +116,7 @@ typedef int php_socket_t; #define STREAM_SOCKOP_SO_BROADCAST (1 << 2) #define STREAM_SOCKOP_IPV6_V6ONLY (1 << 3) #define STREAM_SOCKOP_IPV6_V6ONLY_ENABLED (1 << 4) +#define STREAM_SOCKOP_TCP_NODELAY (1 << 5) /* uncomment this to debug poll(2) emulation on systems that have poll(2) */ @@ -265,7 +267,8 @@ PHPAPI php_socket_t php_network_accept_incoming(php_socket_t srvsock, socklen_t *addrlen, struct timeval *timeout, zend_string **error_string, - int *error_code + int *error_code, + int tcp_nodelay ); PHPAPI int php_network_get_sock_name(php_socket_t sock, diff --git a/main/streams/plain_wrapper.c b/main/streams/plain_wrapper.c index 8c9a888845..d510c909a7 100644 --- a/main/streams/plain_wrapper.c +++ b/main/streams/plain_wrapper.c @@ -1484,7 +1484,7 @@ not_relative_path: } #endif - if (!path || (path && !*path)) { + if (!path || !*path) { return php_stream_fopen_rel(filename, mode, opened_path, options); } diff --git a/main/streams/userspace.c b/main/streams/userspace.c index 00775aa0c8..eb8b32eed9 100644 --- a/main/streams/userspace.c +++ b/main/streams/userspace.c @@ -299,7 +299,6 @@ static void user_stream_create_object(struct php_user_stream_wrapper *uwrap, php zval retval; fci.size = sizeof(fci); - fci.function_table = &uwrap->ce->function_table; ZVAL_UNDEF(&fci.function_name); fci.object = Z_OBJ_P(object); fci.retval = &retval; @@ -309,7 +308,7 @@ static void user_stream_create_object(struct php_user_stream_wrapper *uwrap, php fcc.initialized = 1; fcc.function_handler = uwrap->ce->constructor; - fcc.calling_scope = EG(scope); + fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = Z_OBJCE_P(object); fcc.object = Z_OBJ_P(object); diff --git a/main/streams/xp_socket.c b/main/streams/xp_socket.c index 7a21fbef44..cc76ace510 100644 --- a/main/streams/xp_socket.c +++ b/main/streams/xp_socket.c @@ -742,6 +742,18 @@ static inline int php_tcp_sockop_connect(php_stream *stream, php_netstream_data_ } #endif + if (stream->ops != &php_stream_udp_socket_ops /* TCP_NODELAY is only applicable for TCP */ +#ifdef AF_UNIX + && stream->ops != &php_stream_unix_socket_ops + && stream->ops != &php_stream_unixdg_socket_ops +#endif + && PHP_STREAM_CONTEXT(stream) + && (tmpzval = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), "socket", "tcp_nodelay")) != NULL + && zend_is_true(tmpzval) + ) { + sockopts |= STREAM_SOCKOP_TCP_NODELAY; + } + /* Note: the test here for php_stream_udp_socket_ops is important, because we * want the default to be TCP sockets so that the openssl extension can * re-use this code. */ @@ -783,36 +795,37 @@ static inline int php_tcp_sockop_accept(php_stream *stream, php_netstream_data_t php_stream_xport_param *xparam STREAMS_DC) { int clisock; + zend_bool nodelay = 0; + zval *tmpzval = NULL; xparam->outputs.client = NULL; + if ((NULL != PHP_STREAM_CONTEXT(stream)) && + (tmpzval = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), "socket", "tcp_nodelay")) != NULL && + zend_is_true(tmpzval)) { + nodelay = 1; + } + clisock = php_network_accept_incoming(sock->socket, - xparam->want_textaddr ? &xparam->outputs.textaddr : NULL, - xparam->want_addr ? &xparam->outputs.addr : NULL, - xparam->want_addr ? &xparam->outputs.addrlen : NULL, - xparam->inputs.timeout, - xparam->want_errortext ? &xparam->outputs.error_text : NULL, - &xparam->outputs.error_code - ); + xparam->want_textaddr ? &xparam->outputs.textaddr : NULL, + xparam->want_addr ? &xparam->outputs.addr : NULL, + xparam->want_addr ? &xparam->outputs.addrlen : NULL, + xparam->inputs.timeout, + xparam->want_errortext ? &xparam->outputs.error_text : NULL, + &xparam->outputs.error_code, + nodelay); if (clisock >= 0) { - php_netstream_data_t *clisockdata; - - clisockdata = emalloc(sizeof(*clisockdata)); - - if (clisockdata == NULL) { - close(clisock); - /* technically a fatal error */ - } else { - memcpy(clisockdata, sock, sizeof(*clisockdata)); - clisockdata->socket = clisock; - - xparam->outputs.client = php_stream_alloc_rel(stream->ops, clisockdata, NULL, "r+"); - if (xparam->outputs.client) { - xparam->outputs.client->ctx = stream->ctx; - if (stream->ctx) { - GC_REFCOUNT(stream->ctx)++; - } + php_netstream_data_t *clisockdata = (php_netstream_data_t*) emalloc(sizeof(*clisockdata)); + + memcpy(clisockdata, sock, sizeof(*clisockdata)); + clisockdata->socket = clisock; + + xparam->outputs.client = php_stream_alloc_rel(stream->ops, clisockdata, NULL, "r+"); + if (xparam->outputs.client) { + xparam->outputs.client->ctx = stream->ctx; + if (stream->ctx) { + GC_REFCOUNT(stream->ctx)++; } } } diff --git a/sapi/cli/php_cli.c b/sapi/cli/php_cli.c index 6683f21393..09ce00f9e7 100644 --- a/sapi/cli/php_cli.c +++ b/sapi/cli/php_cli.c @@ -304,7 +304,7 @@ static size_t sapi_cli_ub_write(const char *str, size_t str_length) /* {{{ */ if (cli_shell_callbacks.cli_shell_ub_write) { size_t ub_wrote; ub_wrote = cli_shell_callbacks.cli_shell_ub_write(str, str_length); - if (ub_wrote > -1) { + if (ub_wrote != (size_t) -1) { return ub_wrote; } } diff --git a/sapi/cli/tests/bug64529.phpt b/sapi/cli/tests/bug64529.phpt index 8452953baf..7331b8303e 100644 --- a/sapi/cli/tests/bug64529.phpt +++ b/sapi/cli/tests/bug64529.phpt @@ -5,6 +5,9 @@ Bug #64529 (Ran out of opcode space) if (substr(PHP_OS, 0, 3) == "WIN") { die("skip non windows test"); } +if (!extension_loaded("readline") || !readline_info("done")) { + die("skip readline support required"); +} exec('which expect', $output, $ret); if ($ret) { die("skip no expect installed"); diff --git a/sapi/fpm/tests/010.phpt b/sapi/fpm/tests/010.phpt index f3b768f319..49e1a07923 100644 --- a/sapi/fpm/tests/010.phpt +++ b/sapi/fpm/tests/010.phpt @@ -2,6 +2,12 @@ FPM: Test status page --SKIPIF-- <?php include "skipif.inc"; ?> +--XFAIL-- +randomly intermittently failing all the time in CI, with diff: +017+ active processes: 0 +018+ total processes: 1 +017- active processes: 1 +018- total processes: 2 --FILE-- <?php diff --git a/sapi/phpdbg/phpdbg_frame.c b/sapi/phpdbg/phpdbg_frame.c index d6256a84af..f64d18b4bb 100644 --- a/sapi/phpdbg/phpdbg_frame.c +++ b/sapi/phpdbg/phpdbg_frame.c @@ -36,8 +36,6 @@ void phpdbg_restore_frame(void) /* {{{ */ /* move things back */ EG(current_execute_data) = PHPDBG_FRAME(execute_data); - - EG(scope) = PHPDBG_EX(func)->op_array.scope; } /* }}} */ void phpdbg_switch_frame(int frame) /* {{{ */ @@ -78,8 +76,6 @@ void phpdbg_switch_frame(int frame) /* {{{ */ /* backup things and jump back */ PHPDBG_FRAME(execute_data) = EG(current_execute_data); EG(current_execute_data) = execute_data; - - EG(scope) = PHPDBG_EX(func)->op_array.scope; } phpdbg_notice("frame", "id=\"%d\"", "Switched to frame #%d", frame); diff --git a/sapi/phpdbg/phpdbg_list.c b/sapi/phpdbg/phpdbg_list.c index 93d741c2a6..e31fe199f2 100644 --- a/sapi/phpdbg/phpdbg_list.c +++ b/sapi/phpdbg/phpdbg_list.c @@ -200,11 +200,12 @@ void phpdbg_list_function_byname(const char *str, size_t len) /* {{{ */ /* search active scope if begins with period */ if (func_name[0] == '.') { - if (EG(scope)) { + zend_class_entry *scope = zend_get_executed_scope(); + if (scope) { func_name++; func_name_len--; - func_table = &EG(scope)->function_table; + func_table = &scope->function_table; } else { phpdbg_error("inactive", "type=\"noclasses\"", "No active class"); return; @@ -242,6 +243,7 @@ zend_op_array *phpdbg_compile_file(zend_file_handle *file, int type) { char resolved_path_buf[MAXPATHLEN]; if (zend_stream_fixup(file, &bufptr, &data.len) == FAILURE) { + zend_file_handle_dtor(file); return NULL; } @@ -288,6 +290,8 @@ zend_op_array *phpdbg_compile_file(zend_file_handle *file, int type) { fake.opened_path = NULL; zend_file_handle_dtor(&fake); + zend_file_handle_dtor(file); + file->type = -1; return ret; } diff --git a/sapi/phpdbg/phpdbg_print.c b/sapi/phpdbg/phpdbg_print.c index 3725bf6083..034354a9e7 100644 --- a/sapi/phpdbg/phpdbg_print.c +++ b/sapi/phpdbg/phpdbg_print.c @@ -217,11 +217,13 @@ PHPDBG_PRINT(func) /* {{{ */ zend_string *lcname; /* search active scope if begins with period */ if (func_name[0] == '.') { - if (EG(scope)) { + zend_class_entry *scope = zend_get_executed_scope(); + + if (scope) { func_name++; func_name_len--; - func_table = &EG(scope)->function_table; + func_table = &scope->function_table; } else { phpdbg_error("inactive", "type=\"noclasses\"", "No active class"); return SUCCESS; diff --git a/sapi/phpdbg/phpdbg_prompt.c b/sapi/phpdbg/phpdbg_prompt.c index ac86c15629..3b7274a997 100644 --- a/sapi/phpdbg/phpdbg_prompt.c +++ b/sapi/phpdbg/phpdbg_prompt.c @@ -120,7 +120,6 @@ static inline int phpdbg_call_register(phpdbg_param_t *stack) /* {{{ */ ZVAL_STRINGL(&fci.function_name, lc_name, name->len); fci.size = sizeof(zend_fcall_info); - fci.function_table = &PHPDBG_G(registered); //???fci.symbol_table = zend_rebuild_symbol_table(); fci.object = NULL; fci.retval = &fretval; @@ -688,7 +687,7 @@ PHPDBG_COMMAND(run) /* {{{ */ } /* clean up from last execution */ - if (ex && ex->symbol_table) { + if (ex && (ZEND_CALL_INFO(ex) & ZEND_CALL_HAS_SYMBOL_TABLE)) { zend_hash_clean(ex->symbol_table); } else { zend_rebuild_symbol_table(); @@ -798,7 +797,6 @@ PHPDBG_COMMAND(ev) /* {{{ */ zval retval; zend_execute_data *original_execute_data = EG(current_execute_data); - zend_class_entry *original_scope = EG(scope); zend_vm_stack original_stack = EG(vm_stack); zend_object *ex = NULL; @@ -846,7 +844,6 @@ PHPDBG_COMMAND(ev) /* {{{ */ OBJ_RELEASE(ex); } EG(current_execute_data) = original_execute_data; - EG(scope) = original_scope; EG(vm_stack_top) = original_stack->top; EG(vm_stack_end) = original_stack->end; EG(vm_stack) = original_stack; diff --git a/sapi/phpdbg/phpdbg_watch.c b/sapi/phpdbg/phpdbg_watch.c index 2c324aa5dc..0224ff4fd1 100644 --- a/sapi/phpdbg/phpdbg_watch.c +++ b/sapi/phpdbg/phpdbg_watch.c @@ -680,7 +680,9 @@ static int phpdbg_watchpoint_parse_step(char *name, size_t namelen, char *key, s } static int phpdbg_watchpoint_parse_symtables(char *input, size_t len, int (*callback)(phpdbg_watchpoint_t *)) { - if (EG(scope) && len >= 5 && !memcmp("$this", input, 5)) { + zend_class_entry *scope = zend_get_executed_scope(); + + if (scope && len >= 5 && !memcmp("$this", input, 5)) { zend_hash_str_add(EG(current_execute_data)->symbol_table, ZEND_STRL("this"), &EG(current_execute_data)->This); } diff --git a/tests/lang/030.phpt b/tests/lang/030.phpt index 9ee40ea5aa..7f94b2eb74 100644 --- a/tests/lang/030.phpt +++ b/tests/lang/030.phpt @@ -24,7 +24,8 @@ $bar1->Name = 'outside'; $bar1->echoName(); $List->echoName(); -$bar1 =& foo2(new foo('constructor')); +$foo = new foo('constructor'); +$bar1 =& foo2($foo); $bar1->Name = 'outside'; $bar1->echoName(); diff --git a/tests/lang/045.phpt b/tests/lang/045.phpt index 11598cf035..44fb801410 100644 --- a/tests/lang/045.phpt +++ b/tests/lang/045.phpt @@ -3,7 +3,10 @@ Timeout again inside register_shutdown_function --SKIPIF-- <?php if (getenv("SKIP_SLOW_TESTS")) die("skip slow test"); +if (PHP_ZTS) die("skip hard_timeout works only on no-zts builds"); ?> +--INI-- +hard_timeout=1 --FILE-- <?php set_time_limit(1); diff --git a/win32/build/libs_version.txt b/win32/build/libs_version.txt index 91b1f8503f..978367feed 100644 --- a/win32/build/libs_version.txt +++ b/win32/build/libs_version.txt @@ -13,4 +13,4 @@ libssh2-1.7.0 libtidy-20090406 libxslt-1.1.28 libxml-2.9.3 -openssl-1.0.2g +openssl-1.0.2h |
